From d2ef084eb0e26b5ee18133269249e7a80efb23d6 Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Caol=C3=A1n=20McNamara?= <caolanm@redhat.com>

Date: Mon, 29 Jun 2015 12:26:16 +0200

Subject: [PATCH] update graphite to 1.3.5

(cherry picked from commit c64ea526dc71da6e3aad188ac71e58047ed74b5a)

and sync the various upgrade patches together

Change-Id: I3287d51430d7a0901dd8bbf2458b845bcf92a8d2

Reviewed-on: https://gerrit.libreoffice.org/22210

Reviewed-by: Miklos Vajna <vmiklos@collabora.co.uk>

Tested-by: Miklos Vajna <vmiklos@collabora.co.uk>

---

 download.lst                                  |   3 +-

 editeng/source/editeng/impedit3.cxx           |   6 +-

 external/graphite/StaticLibrary_graphite.mk   |   9 +-

 external/graphite/UnpackedTarball_graphite.mk |   4 +-

 external/graphite/graphite2.issue1115.patch.1 |   6 +-

 external/graphite/graphite2.win64.patch.1     |  34 +-

 external/graphite/ubsan.patch                 |  51 ++

 vcl/inc/graphite_layout.hxx                   |  10 +-

 vcl/source/fontsubset/sft.cxx                 |   3 +

 vcl/source/gdi/pdfwriter_impl.cxx             |  15 +-

 vcl/source/glyphs/graphite_layout.cxx         | 799 +++++++++-----------------

 vcl/win/source/gdi/winlayout.cxx              |  15 +-

 12 files changed, 396 insertions(+), 559 deletions(-)

 create mode 100644 external/graphite/ubsan.patch

diff --git a/download.lst b/download.lst

index bc94112..9e16272 100644

--- a/download.lst

+++ b/download.lst

@@ -59,8 +59,7 @@ export FREEHAND_TARBALL := libfreehand-0.1.1.tar.bz2

 export FREETYPE_TARBALL := dbf2caca1d3afd410a29217a9809d397-freetype-2.4.8.tar.bz2

 export GLEW_TARBALL := 594eb47b4b1210e25438d51825404d5a-glew-1.10.0.zip

 export GLM_TARBALL := bae83fa5dc7f081768daace6e199adc3-glm-0.9.4.6-libreoffice.zip

-export GRAPHITE_MD5SUM := 2ef839348fe28e3b923bf8cced440227

-export GRAPHITE_TARBALL := graphite2-1.2.4.tgz

+export GRAPHITE_TARBALL := 28935e208c311761c29983c739db08d8-graphite2-minimal-1.3.5.tgz

 export HARFBUZZ_MD5SUM := 0e27e531f4c4acff601ebff0957755c2

 export HARFBUZZ_TARBALL := harfbuzz-0.9.40.tar.bz2

 export HSQLDB_TARBALL := 17410483b5b5f267aa18b7e00b65e6e0-hsqldb_1_8_0.zip

diff --git a/editeng/source/editeng/impedit3.cxx b/editeng/source/editeng/impedit3.cxx

index 98e3d51..5df7e5e 100644

--- a/editeng/source/editeng/impedit3.cxx

+++ b/editeng/source/editeng/impedit3.cxx

@@ -714,6 +714,8 @@ bool ImpEditEngine::CreateLines( sal_Int32 nPara, sal_uInt32 nStartPosY )

     EditLine aSaveLine( *pLine );

     SvxFont aTmpFont( pNode->GetCharAttribs().GetDefFont() );

+    ImplInitLayoutMode( GetRefDevice(), nPara, nIndex );

+

     bool bCalcCharPositions = true;

     boost::scoped_array<long> pBuf(new long[ pNode->Len() ]);

@@ -1038,6 +1040,8 @@ bool ImpEditEngine::CreateLines( sal_Int32 nPara, sal_uInt32 nStartPosY )

                 aTmpFont.SetPhysFont( GetRefDevice() );

                 ImplInitDigitMode(GetRefDevice(), aTmpFont.GetLanguage());

+                pPortion->SetRightToLeft( GetRightToLeft( nPara, nTmpPos+1 ) );

+

                 if ( bCalcCharPositions || !pPortion->HasValidSize() )

                 {

                     pPortion->GetSize() = aTmpFont.QuickGetTextSize( GetRefDevice(), pParaPortion->GetNode()->GetString(), nTmpPos, pPortion->GetLen(), pBuf.get() );

@@ -1069,8 +1073,6 @@ bool ImpEditEngine::CreateLines( sal_Int32 nPara, sal_uInt32 nStartPosY )

                 nTmpWidth += pPortion->GetSize().Width();

-                pPortion->SetRightToLeft( GetRightToLeft( nPara, nTmpPos+1 ) );

-

                 sal_Int32 _nPortionEnd = nTmpPos + pPortion->GetLen();

                 if( bScriptSpace && ( _nPortionEnd < pNode->Len() ) && ( nTmpWidth < nXWidth ) && IsScriptChange( EditPaM( pNode, _nPortionEnd ) ) )

                 {

diff --git a/external/graphite/StaticLibrary_graphite.mk b/external/graphite/StaticLibrary_graphite.mk

index de3950f..ddbf995 100644

--- a/external/graphite/StaticLibrary_graphite.mk

+++ b/external/graphite/StaticLibrary_graphite.mk

@@ -19,8 +19,8 @@ $(eval $(call gb_StaticLibrary_set_include,graphite,\

 ))

 $(eval $(call gb_StaticLibrary_add_defs,graphite,\

-	-DDISABLE_TRACING \

-	-DGR2_STATIC \

+	-DGRAPHITE2_NTRACING \

+	-DGRAPHITE2_STATIC \

 ))

 ifeq ($(COM),GCC)

@@ -43,19 +43,22 @@ $(eval $(call gb_StaticLibrary_add_generated_cxxobjects,graphite,\

 	UnpackedTarball/graphite/src/gr_segment \

 	UnpackedTarball/graphite/src/gr_slot \

 	UnpackedTarball/graphite/src/json \

-	UnpackedTarball/graphite/src/Bidi \

 	UnpackedTarball/graphite/src/CachedFace \

 	UnpackedTarball/graphite/src/CmapCache \

 	UnpackedTarball/graphite/src/Code \

+	UnpackedTarball/graphite/src/Collider \

+	UnpackedTarball/graphite/src/Decompressor \

 	UnpackedTarball/graphite/src/Face \

 	UnpackedTarball/graphite/src/FeatureMap \

 	UnpackedTarball/graphite/src/FileFace \

 	UnpackedTarball/graphite/src/Font \

 	UnpackedTarball/graphite/src/GlyphCache \

 	UnpackedTarball/graphite/src/GlyphFace \

+	UnpackedTarball/graphite/src/Intervals \

 	UnpackedTarball/graphite/src/Justifier \

 	UnpackedTarball/graphite/src/NameTable \

 	UnpackedTarball/graphite/src/Pass \

+	UnpackedTarball/graphite/src/Position \

 	UnpackedTarball/graphite/src/SegCache \

 	UnpackedTarball/graphite/src/SegCacheEntry \

 	UnpackedTarball/graphite/src/SegCacheStore \

diff --git a/external/graphite/UnpackedTarball_graphite.mk b/external/graphite/UnpackedTarball_graphite.mk

index c7fa86e..a162d17 100644

--- a/external/graphite/UnpackedTarball_graphite.mk

+++ b/external/graphite/UnpackedTarball_graphite.mk

@@ -11,10 +11,12 @@ $(eval $(call gb_UnpackedTarball_UnpackedTarball,graphite))

 $(eval $(call gb_UnpackedTarball_set_tarball,graphite,$(GRAPHITE_TARBALL)))

-# http://projects.palaso.org/issues/1115

+$(eval $(call gb_UnpackedTarball_set_patchlevel,graphite,0))

+

 $(eval $(call gb_UnpackedTarball_add_patches,graphite,\

 	external/graphite/graphite2.issue1115.patch.1 \

     external/graphite/graphite2.win64.patch.1 \

+    external/graphite/ubsan.patch \

 ))

 # vim: set noet sw=4 ts=4:

diff --git a/external/graphite/graphite2.issue1115.patch.1 b/external/graphite/graphite2.issue1115.patch.1

index f19c8a3..454114b 100644

--- a/external/graphite/graphite2.issue1115.patch.1

+++ b/external/graphite/graphite2.issue1115.patch.1

@@ -1,6 +1,6 @@

 --- graphite/src/Code.cpp

 +++ graphite/src/Code.cpp

-@@ -169,8 +169,8 @@ Machine::Code::Code(bool is_constraint,

+@@ -175,8 +175,8 @@ Machine::Code::Code(bool is_constraint,

          bytecode_end,

          pre_context,

          rule_length,

@@ -11,7 +11,7 @@

          face.numFeatures(), 

          {1,1,1,1,1,1,1,1, 

           1,1,1,1,1,1,1,255,

-@@ -178,7 +178,7 @@ Machine::Code::Code(bool is_constraint,

+@@ -184,7 +184,7 @@ Machine::Code::Code(bool is_constraint,

           1,1,1,1,1,1,0,0, 

           0,0,0,0,0,0,0,0, 

           0,0,0,0,0,0,0,0, 

@@ -19,4 +19,4 @@

 +         0,0,0,0,0,0,0, static_cast<byte>(silf.numUser())}

      };

-     decoder dec(lims, *this);

+     decoder dec(lims, *this, pt);

diff --git a/external/graphite/graphite2.win64.patch.1 b/external/graphite/graphite2.win64.patch.1

index 6bf8c88..e7c36c6 100644

--- a/external/graphite/graphite2.win64.patch.1

+++ b/external/graphite/graphite2.win64.patch.1

@@ -1,7 +1,20 @@

+diff -ur graphite.org/src/inc/Main.h graphite/src/inc/Main.h

+--- graphite.org/src/inc/Main.h	2015-09-07 20:09:25.572279671 +0700

+--- graphite/src/inc/Main.h	2015-09-07 20:09:25.572279671 +0700

+@@ -25,6 +25,9 @@

+ of the License or (at your option) any later version.

+ */

+ #pragma once

++#ifdef _WIN32

++#pragma warning(disable: 4510 4610)

++#endif

+ 

+ #include <cstdlib>

+ #include "graphite2/Types.h"

 diff -ur graphite.org/src/inc/json.h graphite/src/inc/json.h

 --- graphite.org/src/inc/json.h	2015-02-03 14:49:24.408101900 +0100

 +++ graphite/src/inc/json.h	2015-02-03 14:50:59.697552200 +0100

-@@ -78,6 +78,9 @@

+@@ -85,6 +85,9 @@

      json & operator << (string) throw();

      json & operator << (number) throw();

      json & operator << (integer) throw();

@@ -14,8 +27,7 @@ diff -ur graphite.org/src/inc/json.h graphite/src/inc/json.h

 diff -ur graphite.org/src/json.cpp graphite/src/json.cpp

 --- graphite.org/src/json.cpp	2015-02-03 14:49:24.409102000 +0100

 +++ graphite/src/json.cpp	2015-02-03 14:50:49.814986900 +0100

-@@ -119,6 +119,9 @@

- json & json::operator << (json::number f) throw()   { context(seq); fprintf(_stream, "%g", f); return *this; }

+@@ -134,5 +134,8 @@

  json & json::operator << (json::integer d) throw()  { context(seq); fprintf(_stream, "%ld", d); return *this; }

  json & json::operator << (long unsigned d) throw()  { context(seq); fprintf(_stream, "%ld", d); return *this; }

 +#ifdef _WIN64

@@ -27,17 +39,17 @@ diff -ur graphite.org/src/json.cpp graphite/src/json.cpp

 diff -ur graphite.org/src/Pass.cpp graphite/src/Pass.cpp

 --- graphite.org/src/Pass.cpp	2015-02-03 14:49:24.413102200 +0100

 +++ graphite/src/Pass.cpp	2015-02-03 14:50:37.873303900 +0100

-@@ -466,7 +466,7 @@

-     {

-         if (r->rule->preContext > fsm.slots.context())  continue;

-     *fsm.dbgout << json::flat << json::object

--                    << "id"     << r->rule - m_rules

-+                    << "id"     << static_cast<size_t>(r->rule - m_rules)

+@@ -544,7 +544,7 @@

+         if (r->rule->preContext > fsm.slots.context())

+             continue;

+         *fsm.dbgout << json::flat << json::object

+-                    << "id" << r->rule - m_rules

++                    << "id" << static_cast<size_t>(r->rule - m_rules)

                      << "failed" << true

                      << "input" << json::flat << json::object

                          << "start" << objectid(dslot(&fsm.slots.segment, input_slot(fsm.slots, -r->rule->preContext)))

-@@ -480,7 +480,7 @@

- void Pass::dumpRuleEventOutput(const FiniteStateMachine & fsm, const Rule & r, Slot * const last_slot) const

+@@ -558,7 +558,7 @@

+ void Pass::dumpRuleEventOutput(const FiniteStateMachine & fsm, Machine & m, const Rule & r, Slot * const last_slot) const

  {

      *fsm.dbgout     << json::item << json::flat << json::object

 -                        << "id"     << &r - m_rules

diff --git a/external/graphite/ubsan.patch b/external/graphite/ubsan.patch

new file mode 100644

index 0000000..b1617b1

--- /dev/null

+++ b/external/graphite/ubsan.patch

@@ -0,0 +1,51 @@

+--- src/Pass.cpp

++++ src/Pass.cpp

+@@ -294,7 +294,7 @@

+         s->rules = begin;

+         s->rules_end = (end - begin <= FiniteStateMachine::MAX_RULES)? end :

+             begin + FiniteStateMachine::MAX_RULES;

+-        qsort(begin, end - begin, sizeof(RuleEntry), &cmpRuleEntry);

++        if (end != begin) qsort(begin, end - begin, sizeof(RuleEntry), &cmpRuleEntry);

+     }

+ 

+     return true;

+--- src/gr_face.cpp

++++ src/gr_face.cpp

+@@ -87,7 +87,7 @@

+ 

+     Face *res = new Face(appFaceHandle, *ops);

+     if (res && load_face(*res, faceOptions))

+-        return static_cast<gr_face *>(res);

++        return reinterpret_cast<gr_face *>(res);

+ 

+     delete res;

+     return 0;

+@@ -195,7 +195,7 @@

+ 

+ void gr_face_destroy(gr_face *face)

+ {

+-    delete face;

++    delete static_cast<Face *>(face);

+ }

+ 

+ 

+--- src/gr_font.cpp

++++ src/gr_font.cpp

+@@ -50,7 +50,7 @@

+     if (face == 0)  return 0;

+ 

+     Font * const res = new Font(ppm, *face, appFontHandle, font_ops);

+-    return static_cast<gr_font*>(res);

++    return reinterpret_cast<gr_font*>(res);

+ }

+ 

+ gr_font* gr_make_font_with_advance_fn(float ppm/*pixels per em*/, const void* appFontHandle/*non-NULL*/, gr_advance_fn getAdvance, const gr_face * face/*needed for scaling*/)

+@@ -61,7 +61,7 @@

+ 

+ void gr_font_destroy(gr_font *font)

+ {

+-    delete font;

++    delete static_cast<Font *>(font);

+ }

+ 

+ 

diff --git a/vcl/inc/graphite_layout.hxx b/vcl/inc/graphite_layout.hxx

index 55d0d67..b97b351 100644

--- a/vcl/inc/graphite_layout.hxx

+++ b/vcl/inc/graphite_layout.hxx

@@ -93,9 +93,10 @@ public:

 private:

     const gr_face *         mpFace; // not owned by layout

     gr_font *               mpFont; // not owned by layout

-    int                     mnSegCharOffset; // relative to ImplLayoutArgs::mpStr

+    unsigned int            mnSegCharOffset; // relative to ImplLayoutArgs::mpStr

     long                    mnWidth;

     std::vector<int>        mvChar2BaseGlyph;

+    std::vector<int>        mvChar2Glyph;

     std::vector<int>        mvGlyph2Char;

     std::vector<int>        mvCharDxs;

     std::vector<int>        mvCharBreaks;

@@ -109,8 +110,6 @@ public:

     // used by upper layers

     virtual bool  LayoutText( ImplLayoutArgs& ) SAL_OVERRIDE;    // first step of layout

     // split into two stages to allow dc to be restored on the segment

-    gr_segment * CreateSegment(ImplLayoutArgs& rArgs);

-    bool LayoutGlyphs(ImplLayoutArgs& rArgs, gr_segment * pSegment);

     virtual void  AdjustLayout( ImplLayoutArgs& ) SAL_OVERRIDE;  // adjusting positions

@@ -145,13 +144,14 @@ public:

     static const int EXTRA_CONTEXT_LENGTH;

 private:

     void expandOrCondense(ImplLayoutArgs &rArgs);

-    void    fillFrom(gr_segment * rSeg, ImplLayoutArgs & rArgs, float fScaling);

+    void    fillFrom(gr_segment * rSeg, ImplLayoutArgs & rArgs, float fScaling, bool bRtl, int firstCharOffset);

     float append(gr_segment * pSeg,

                 ImplLayoutArgs & rArgs,

                 const gr_slot * pSlot, float gOrigin,

                 float nextGlyphOrigin, float fScaling,

-                long & rDXOffset, bool bIsBase, int baseChar);

+                long & rDXOffset, bool bIsBase, int baseChar, int baseGlyph, bool bRtl);

+    unsigned int ScanFwdForChar(int &findChar, bool fallback) const;

 };

 #endif // INCLUDED_VCL_INC_GRAPHITE_LAYOUT_HXX

diff --git a/vcl/source/fontsubset/sft.cxx b/vcl/source/fontsubset/sft.cxx

index 6758df2..fe4abe7 100644

--- a/vcl/source/fontsubset/sft.cxx

+++ b/vcl/source/fontsubset/sft.cxx

@@ -1770,6 +1770,9 @@ int GetTTGlyphComponents(TrueTypeFont *ttf, sal_uInt32 glyphID, std::vector< sal

     const sal_uInt8* glyf = getTable(ttf, O_glyf);

     const sal_uInt8* ptr = glyf + ttf->goffsets[glyphID];

+    const sal_uInt8* nptr = glyf + ttf->goffsets[glyphID+1];

+    if (nptr <= ptr)

+        return 0;

     glyphlist.push_back( glyphID );

diff --git a/vcl/source/gdi/pdfwriter_impl.cxx b/vcl/source/gdi/pdfwriter_impl.cxx

index f2974a2..44d1f45 100644

--- a/vcl/source/gdi/pdfwriter_impl.cxx

+++ b/vcl/source/gdi/pdfwriter_impl.cxx

@@ -9006,22 +9006,27 @@ void PDFWriterImpl::drawLayout( SalLayout& rLayout, const OUString& rText, bool

             else if( pCharPosAry[i] >= nMinCharPos && pCharPosAry[i] <= nMaxCharPos )

             {

                 int nChars = 1;

-                aUnicodes.push_back( rText[ pCharPosAry[i] ] );

                 pUnicodesPerGlyph[i] = 1;

                 // try to handle ligatures and such

                 if( i < nGlyphs-1 )

                 {

                     nChars = pCharPosAry[i+1] - pCharPosAry[i];

+                    int start = pCharPosAry[i];

                     // #i115618# fix for simple RTL+CTL cases

-                    // TODO: sanitize for RTL ligatures, more complex CTL, etc.

+                    // supports RTL ligatures. TODO: more complex CTL, etc.

                     if( nChars < 0 )

+                    {

                         nChars = -nChars;

-                    else if( nChars == 0 )

+                        start = pCharPosAry[i+1] + 1;

+                    }

+                    else if (nChars == 0)

                         nChars = 1;

                     pUnicodesPerGlyph[i] = nChars;

-                    for( int n = 1; n < nChars; n++ )

-                        aUnicodes.push_back( rText[ pCharPosAry[i] + n ] );

+                    for( int n = 0; n < nChars; n++ )

+                        aUnicodes.push_back( rText[ start + n ] );

                 }

+                else

+                    aUnicodes.push_back( rText[ pCharPosAry[i] ] );

                 // #i36691# hack that is needed because currently the pGlyphs[]

                 // argument is ignored for embeddable fonts and so the layout

                 // engine's glyph work is ignored (i.e. char mirroring)

diff --git a/vcl/source/glyphs/graphite_layout.cxx b/vcl/source/glyphs/graphite_layout.cxx

index a4aa99c..db50a22 100644

--- a/vcl/source/glyphs/graphite_layout.cxx

+++ b/vcl/source/glyphs/graphite_layout.cxx

@@ -27,7 +27,7 @@

 #undef NDEBUG

 #endif

-// #define GRLAYOUT_DEBUG 1

+//#define GRLAYOUT_DEBUG 1

 #include <algorithm>

 #include <cassert>

@@ -89,23 +89,6 @@ namespace

         return !(b > i) && i < e;

     }

-    int findSameDirLimit(const sal_Unicode* buffer, int charCount, bool rtl)

-    {

-        UErrorCode status = U_ZERO_ERROR;

-        UBiDi *ubidi = ubidi_openSized(charCount, 0, &status);

-        int limit = 0;

-        ubidi_setPara(ubidi, reinterpret_cast<const UChar *>(buffer), charCount,

-            (rtl)?UBIDI_DEFAULT_RTL:UBIDI_DEFAULT_LTR, NULL, &status);

-        UBiDiLevel level = 0;

-        ubidi_getLogicalRun(ubidi, 0, &limit, &level);

-        ubidi_close(ubidi);

-        if ((rtl && !(level & 1)) || (!rtl && (level & 1)))

-        {

-            limit = 0;

-        }

-        return limit;

-    }

-

     template <typename T>

     T maximum(T a, T b)

     {

@@ -125,43 +108,21 @@ namespace

 //        o Querying clustering relationships.

 //        o manipulations that affect neighouring glyphs.

-const int GraphiteLayout::EXTRA_CONTEXT_LENGTH = 10;

+const int GraphiteLayout::EXTRA_CONTEXT_LENGTH = 32;

-// find first slot of cluster and first slot of subsequent cluster

-static void findFirstClusterSlot(const gr_slot* base, gr_slot const** first, gr_slot const** after, int * firstChar, int * lastChar, bool bRtl)

+const gr_slot *get_next_base(const gr_slot *slot, bool bRtl)

 {

-    if (gr_slot_attached_to(base) == NULL)

-    {

-        *first = base;

-        *after = (bRtl)? gr_slot_prev_in_segment(base) :

-            gr_slot_next_in_segment(base);

-        *firstChar = gr_slot_before(base);

-        *lastChar = gr_slot_after(base);

-    }

-    const gr_slot * attachment = gr_slot_first_attachment(base);

-    while (attachment)

-    {

-        if (gr_slot_origin_X(*first) > gr_slot_origin_X(attachment))

-            *first = attachment;

-        const gr_slot* attachmentNext = (bRtl)?

-            gr_slot_prev_in_segment(attachment) : gr_slot_next_in_segment(attachment);

-        if (attachmentNext)

-        {

-            if (*after && (gr_slot_origin_X(*after) < gr_slot_origin_X(attachmentNext)))

-                *after = attachmentNext;

-        }

-        else

-        {

-            *after = NULL;

-        }

-        if (gr_slot_before(attachment) < *firstChar)

-            *firstChar = gr_slot_before(attachment);

-        if (gr_slot_after(attachment) > *lastChar)

-            *lastChar = gr_slot_after(attachment);

-        if (gr_slot_first_attachment(attachment))

-            findFirstClusterSlot(attachment, first, after, firstChar, lastChar, bRtl);

-        attachment = gr_slot_next_sibling_attachment(attachment);

-    }

+    for ( ; slot; slot = bRtl ? gr_slot_prev_in_segment(slot) : gr_slot_next_in_segment(slot))

+        if (!gr_slot_attached_to(slot) || gr_slot_can_insert_before(slot))

+            break;

+    return slot;

+}

+

+bool isWhite(sal_Unicode nChar)

+{

+    if (nChar <= 0x0020 || nChar == 0x00A0 || (nChar >= 0x2000 && nChar <= 0x200F) || nChar == 0x3000)

+        return true;

+    return false;

 }

 // The Graphite glyph stream is really a sequence of glyph attachment trees

@@ -169,202 +130,131 @@ static void findFirstClusterSlot(const gr_slot* base, gr_slot const** first, gr_

 //  finds each non-attached base glyph and calls append to record them as a

 //  sequence of clusters.

 void

-GraphiteLayout::fillFrom(gr_segment * pSegment, ImplLayoutArgs &rArgs, float fScaling)

+GraphiteLayout::fillFrom(gr_segment * pSegment, ImplLayoutArgs &rArgs, float fScaling, bool bRtl, int lastCharPos)

 {

-    bool bRtl(rArgs.mnFlags & SalLayoutFlags::BiDiRtl);

-    int nCharRequested = rArgs.mnEndCharPos - rArgs.mnMinCharPos;

-    int nChar = gr_seg_n_cinfo(pSegment);

     float fMinX = gr_seg_advance_X(pSegment);

     float fMaxX = 0.0f;

     long nDxOffset = 0; // from dropped glyphs

-    int nFirstCharInCluster = 0;

-    int nLastCharInCluster = 0;

+    int origNumGlyphs = mvGlyphs.size();

     unsigned int nGlyphs = gr_seg_n_slots(pSegment);

-    mvGlyph2Char.assign(nGlyphs, -1);

-    mvGlyphs.reserve(nGlyphs);

-

-    if (bRtl)

+    mvGlyph2Char.resize(mvGlyph2Char.size() + nGlyphs, -1);

+    mvGlyphs.reserve(mvGlyphs.size() + nGlyphs);

+    int clusterStart = -1;

+    int clusterFirstChar = -1;

+    const gr_slot *nextBaseSlot;

+    const sal_Unicode *pStr = rArgs.mpStr;

+    int firstChar;

+

+    if (!nGlyphs || lastCharPos - mnSegCharOffset == 0) return;

+    const gr_slot* baseSlot = bRtl ? gr_seg_last_slot(pSegment) : gr_seg_first_slot(pSegment);

+    // find first base

+    while (baseSlot && gr_slot_attached_to(baseSlot) != NULL && !gr_slot_can_insert_before(baseSlot))

+        baseSlot = bRtl ? gr_slot_prev_in_segment(baseSlot) : gr_slot_next_in_segment(baseSlot);

+    assert(baseSlot);

+    int nextChar = gr_cinfo_base(gr_seg_cinfo(pSegment, gr_slot_before(baseSlot))) + mnSegCharOffset;

+    float thisBoundary = 0.;

+    float nextBoundary = gr_slot_origin_X(baseSlot);

+    // now loop over bases

+    for ( ; baseSlot; baseSlot = nextBaseSlot)

     {

-        const gr_slot* baseSlot = gr_seg_last_slot(pSegment);

-        // find first base

-        while (baseSlot && (gr_slot_attached_to(baseSlot) != NULL))

-            baseSlot = gr_slot_prev_in_segment(baseSlot);

-        int iChar = nChar - 1;

-        int iNextChar = nChar - 1;

-        bool reordered = false;

-        int nBaseGlyphIndex = 0;

-        // now loop over bases

-        while (baseSlot)

+        firstChar = nextChar;

+        thisBoundary = nextBoundary;

+        nextBaseSlot = get_next_base(bRtl ? gr_slot_prev_in_segment(baseSlot) : gr_slot_next_in_segment(baseSlot), bRtl);

+        nextChar = nextBaseSlot ? gr_cinfo_base(gr_seg_cinfo(pSegment, gr_slot_before(nextBaseSlot))) + mnSegCharOffset : -1;

+        nextBoundary = nextBaseSlot ? gr_slot_origin_X(nextBaseSlot) : gr_seg_advance_X(pSegment);

+

+        if (firstChar < mnMinCharPos || firstChar >= mnEndCharPos)

         {

-            bool bCluster = !reordered;

-            const gr_slot * clusterFirst = NULL;

-            const gr_slot * clusterAfter = NULL;

-            int firstChar = -1;

-            int lastChar = -1;

-            findFirstClusterSlot(baseSlot, &clusterFirst, &clusterAfter, &firstChar, &lastChar, bRtl);

-            iNextChar = minimum<int>(firstChar, iNextChar);

-            if (bCluster)

-            {

-                nBaseGlyphIndex = mvGlyphs.size();

-                mvGlyph2Char[nBaseGlyphIndex] = iChar + mnSegCharOffset;

-                nFirstCharInCluster = firstChar;

-                nLastCharInCluster = lastChar;

-            }

-            else

-            {

-                mvGlyph2Char[mvGlyphs.size()] = firstChar + mnSegCharOffset;

-                nFirstCharInCluster = minimum<int>(firstChar, nFirstCharInCluster);

-                nLastCharInCluster = maximum<int>(firstChar, nLastCharInCluster);

-            }

-            float leftBoundary = gr_slot_origin_X(clusterFirst);

-            float rightBoundary = (clusterAfter)?

-                gr_slot_origin_X(clusterAfter) : gr_seg_advance_X(pSegment);

-            if (

-                lastChar < iChar && clusterAfter &&

-                 (gr_cinfo_after(gr_seg_cinfo(pSegment, iChar)) >

-                 static_cast<int>(gr_slot_index(clusterAfter)))

-               )

-            {

-                reordered = true;

-            }

-            else

-            {

-                reordered = false;

-                iChar = iNextChar - 1;

-            }

-            if (mnSegCharOffset + nFirstCharInCluster >= mnMinCharPos &&

-                mnSegCharOffset + nFirstCharInCluster < mnEndCharPos)

-            {

-                fMinX = minimum<float>(fMinX, leftBoundary);

-                fMaxX = maximum<float>(fMaxX, rightBoundary);

-                if (!reordered)

-                {

-                    for (int i = nFirstCharInCluster; i <= nLastCharInCluster; i++)

-                    {

-                        if (mnSegCharOffset + i >= mnEndCharPos)

-                            break;

-                        // from the point of view of the dx array, the xpos is

-                        // the origin of the first glyph of the cluster rtl

-                        mvCharDxs[mnSegCharOffset + i - mnMinCharPos] =

-                            static_cast<int>(leftBoundary * fScaling) + nDxOffset;

-                        mvCharBreaks[mnSegCharOffset + i - mnMinCharPos] = gr_cinfo_break_weight(gr_seg_cinfo(pSegment, i));

-                    }

-                    mvChar2BaseGlyph[mnSegCharOffset + nFirstCharInCluster - mnMinCharPos] = nBaseGlyphIndex;

-                }

-                append(pSegment, rArgs, baseSlot, gr_slot_origin_X(baseSlot), rightBoundary, fScaling,

-                       nDxOffset, bCluster, mnSegCharOffset + firstChar);

-            }

-            if (mnSegCharOffset + nLastCharInCluster < mnMinCharPos)

-                break;

-            baseSlot = gr_slot_next_sibling_attachment(baseSlot);

+            // handle clipping of diacritic from base

+            nextBaseSlot = bRtl ? gr_slot_prev_in_segment(baseSlot) : gr_slot_next_in_segment(baseSlot);

+            nextBoundary = nextBaseSlot ? gr_slot_origin_X(nextBaseSlot) : gr_seg_advance_X(pSegment);

+            nextChar = nextBaseSlot ? gr_cinfo_base(gr_seg_cinfo(pSegment, gr_slot_before(nextBaseSlot))) + mnSegCharOffset : -1;

+            continue;

         }

-    }

-    else

-    {

-        const gr_slot* baseSlot = gr_seg_first_slot(pSegment);

-        // find first base

-        while (baseSlot && (gr_slot_attached_to(baseSlot) != NULL))

-            baseSlot = gr_slot_next_in_segment(baseSlot);

-        int iChar = 0; // relative to segment

-        int iNextChar = 0;

-        bool reordered = false;

-        int nBaseGlyphIndex = 0;

-        // now loop over bases

-        while (baseSlot)

+        // handle reordered clusters. Presumes reordered glyphs have monotonic opposite char index until the cluster base.

+        bool isReordered = (nextBaseSlot && ((bRtl != (gr_cinfo_base(gr_seg_cinfo(pSegment, gr_slot_before(nextBaseSlot))) < firstChar - mnSegCharOffset))

+                                             || gr_cinfo_base(gr_seg_cinfo(pSegment, gr_slot_before(nextBaseSlot))) == firstChar - mnSegCharOffset));

+        if (clusterStart >= 0 && !isReordered)      // we hit the base (end) of a reordered cluster

         {

-            bool bCluster = !reordered;

-            const gr_slot * clusterFirst = NULL;

-            const gr_slot * clusterAfter = NULL;

-            int firstChar = -1;

-            int lastChar = -1;

-            findFirstClusterSlot(baseSlot, &clusterFirst, &clusterAfter, &firstChar, &lastChar, bRtl);

-            iNextChar = maximum<int>(lastChar, iNextChar);

-            if (bCluster)

-            {

-                nBaseGlyphIndex = mvGlyphs.size();

-                mvGlyph2Char[nBaseGlyphIndex] = iChar + mnSegCharOffset;

-                nFirstCharInCluster = firstChar;

-                nLastCharInCluster = lastChar;

-            }

-            else

-            {

-                mvGlyph2Char[mvGlyphs.size()] = firstChar + mnSegCharOffset;

-                nFirstCharInCluster = minimum<int>(firstChar, nFirstCharInCluster);

-                nLastCharInCluster = maximum<int>(lastChar, nLastCharInCluster);

-            }

-            if (

-                firstChar > iChar &&

-                 (gr_cinfo_before(gr_seg_cinfo(pSegment, iChar)) >

-                 static_cast<int>(gr_slot_index(clusterFirst)))

-               )

+            int clusterEnd = mvGlyphs.size();

+            for (int i = clusterStart; i < clusterEnd; ++i)

+                mvGlyph2Char[i] = firstChar;

+            if (bRtl)

             {

-                reordered = true;

+                for ( ; clusterFirstChar < firstChar; ++clusterFirstChar)

+                    if (clusterFirstChar >= mnMinCharPos && clusterFirstChar < mnEndCharPos)

+                    {

+                        mvChar2BaseGlyph[clusterFirstChar - mnMinCharPos] = clusterStart;  // lowest glyphItem index

+                        mvCharDxs[clusterFirstChar - mnMinCharPos] = static_cast<int>(thisBoundary * fScaling) + mnWidth + nDxOffset;

+                    }

             }

             else

             {

-                reordered = false;

-                iChar = iNextChar + 1;

-            }

-            float leftBoundary = gr_slot_origin_X(clusterFirst);

-            float rightBoundary = (clusterAfter)?

-                gr_slot_origin_X(clusterAfter) : gr_seg_advance_X(pSegment);

-            int bFirstChar = gr_cinfo_base(gr_seg_cinfo(pSegment, nFirstCharInCluster));

-            if (mnSegCharOffset + bFirstChar >= mnMinCharPos &&

-                mnSegCharOffset + bFirstChar < mnEndCharPos)

-            {

-                fMinX = minimum<float>(fMinX, leftBoundary);

-                fMaxX = maximum<float>(fMaxX, rightBoundary);

-                if (!reordered)

-                {

-                    for (int i = nFirstCharInCluster; i <= nLastCharInCluster; i++)

+                for ( ; clusterFirstChar > firstChar; --clusterFirstChar)

+                    if (clusterFirstChar < mnEndCharPos && clusterFirstChar >= mnMinCharPos)

                     {

-                        int ibase = gr_cinfo_base(gr_seg_cinfo(pSegment, i));

-                        if (mnSegCharOffset + ibase >= mnEndCharPos)

-                            break;

-                        // from the point of view of the dx array, the xpos is

-                        // the origin of the first glyph of the next cluster ltr

-                        mvCharDxs[mnSegCharOffset + ibase - mnMinCharPos] =

-                            static_cast<int>(rightBoundary * fScaling) + nDxOffset;

-                        mvCharBreaks[mnSegCharOffset + ibase - mnMinCharPos] = gr_cinfo_break_weight(gr_seg_cinfo(pSegment, i));

+                        mvChar2BaseGlyph[clusterFirstChar - mnMinCharPos] = clusterStart;

+                        mvCharDxs[clusterFirstChar - mnMinCharPos] = static_cast<int>(nextBoundary * fScaling) + mnWidth + nDxOffset;

                     }

-                    // only set mvChar2BaseGlyph for first character of cluster

-                    mvChar2BaseGlyph[mnSegCharOffset + bFirstChar - mnMinCharPos] = nBaseGlyphIndex;

-                }

-                append(pSegment, rArgs, baseSlot, gr_slot_origin_X(baseSlot), rightBoundary, fScaling,

-                       nDxOffset, true, mnSegCharOffset + firstChar);

             }

-            if (mnSegCharOffset + bFirstChar >= mnEndCharPos)

-                break;

-            baseSlot = gr_slot_next_sibling_attachment(baseSlot);

+            clusterStart = -1;

+            clusterFirstChar = -1;

+        }

+        else if (clusterStart < 0 && isReordered) // we hit the start of a reordered cluster

+        {

+            clusterStart = mvGlyphs.size();

+            clusterFirstChar = firstChar;

+        }

+

+        int baseGlyph = mvGlyphs.size();

+        int scaledGlyphPos = round_to_long(gr_slot_origin_X(baseSlot) * fScaling) + mnWidth + nDxOffset;

+        if (mvChar2Glyph[firstChar - mnMinCharPos] == -1 || mvGlyphs[mvChar2Glyph[firstChar - mnMinCharPos]].maLinearPos.X() < scaledGlyphPos)

+        {

+            mvChar2Glyph[firstChar - mnMinCharPos] = mvGlyphs.size();

+            mvCharDxs[firstChar - mnMinCharPos] = static_cast<int>((bRtl ? thisBoundary : nextBoundary) * fScaling) + mnWidth + nDxOffset;

+            mvChar2BaseGlyph[firstChar - mnMinCharPos] = baseGlyph;

+            mvCharBreaks[firstChar - mnMinCharPos] = gr_cinfo_break_weight(gr_seg_cinfo(pSegment, gr_slot_before(baseSlot)));

         }

+        mvGlyph2Char[baseGlyph] = firstChar;

+        append(pSegment, rArgs, baseSlot, thisBoundary, nextBoundary, fScaling, nDxOffset, true, firstChar, baseGlyph, bRtl);

+        if (thisBoundary < fMinX) fMinX = thisBoundary;

+        if (nextBoundary > fMaxX && (nextChar < mnMinCharPos || nextChar >= mnEndCharPos || !isWhite(pStr[nextChar]) || fMaxX <= 0.0f))

+            fMaxX = nextBoundary;

     }

+

     long nXOffset = round_to_long(fMinX * fScaling);

-    mnWidth = round_to_long(fMaxX * fScaling) - nXOffset + nDxOffset;

-    if (mnWidth < 0)

-    {

-        // This can happen when there was no base inside the range

-        mnWidth = 0;