Merge branch 'AmmrFX-master'

Author: oneplus1000

arabic_alphabet.go

@@ -5,6 +5,67 @@ type Harf struct {
 	Unicode, Isolated, Beginning, Middle, Final rune
 }
 
+const (
+	FATHA  rune = '\u064E' // َ (short a)
+	DAMMA  rune = '\u064F' // ُ (short u)
+	KASRA  rune = '\u0650' // ِ (short i)
+	SUKUN  rune = '\u0652' // ْ (no vowel)
+	SHADDA rune = '\u0651' // ّ (gemination/doubling)
+
+	// Tanween (nutation)
+	TANWEEN_FATH rune = '\u064B' // ً (an)
+	TANWEEN_DAMM rune = '\u064C' // ٌ (un)
+	TANWEEN_KASR rune = '\u064D' // ٍ (in)
+
+	// Quranic / Extended marks
+	SUPERSCRIPT_ALEF rune = '\u0670' // ٰ (dagger alef)
+	MADDAH_ABOVE     rune = '\u0653' // ٓ (maddah)
+	HAMZA_ABOVE      rune = '\u0654' // ٔ (hamza above)
+	HAMZA_BELOW      rune = '\u0655' // ٕ (hamza below)
+	SUBSCRIPT_ALEF   rune = '\u0656' // ٖ (subscript alef)
+	INVERTED_DAMMA   rune = '\u0657' // ٗ (inverted damma)
+	MARK_NOON_GHUNNA rune = '\u0658' // ٘ (noon ghunna)
+
+	// Shadda + Vowel Ligatures (Arabic Presentation Forms-B)
+	SHADDA_FATHA          rune = '\uFC60' // ﱠ
+	SHADDA_DAMMA          rune = '\uFC61' // ﱡ
+	SHADDA_KASRA          rune = '\uFC62' // ﱢ
+	SHADDA_DAMMATAN       rune = '\uFC5E' // ﱞ (Shadda + Tanween Damm)
+	SHADDA_KASRATAN       rune = '\uFC5F' // ﱟ (Shadda + Tanween Kasr)
+	SHADDA_SUPERSCRIPT_ALEF rune = '\uFC63' // ﱣ
+)
+
+var tashkeelMarks = map[rune]bool{
+	// Basic
+	FATHA: true, DAMMA: true, KASRA: true,
+	SHADDA: true, SUKUN: true,
+
+	// Tanween
+	TANWEEN_DAMM: true, TANWEEN_FATH: true, TANWEEN_KASR: true,
+
+	// Quranic/Extended
+	SUPERSCRIPT_ALEF: true, MADDAH_ABOVE: true,
+	HAMZA_ABOVE: true, HAMZA_BELOW: true,
+	SUBSCRIPT_ALEF: true, INVERTED_DAMMA: true,
+	MARK_NOON_GHUNNA: true,
+}
+
+// shaddaLigatures maps vowels to their combined Shadda+Vowel ligature form
+var shaddaLigatures = map[rune]rune{
+	FATHA:            SHADDA_FATHA,
+	DAMMA:            SHADDA_DAMMA,
+	KASRA:            SHADDA_KASRA,
+	TANWEEN_DAMM:     SHADDA_DAMMATAN,
+	TANWEEN_KASR:     SHADDA_KASRATAN,
+	SUPERSCRIPT_ALEF: SHADDA_SUPERSCRIPT_ALEF,
+}
+
+// GetShaddaLigature returns the combined Shadda+Vowel ligature for a given vowel.
+// Returns 0 if no ligature exists for the vowel.
+func GetShaddaLigature(vowel rune) rune {
+	return shaddaLigatures[vowel]
+}
+
 // Arabic Alphabet using the new Harf type.
 var (
 	ALEF_HAMZA_ABOVE = Harf{ // أ
@@ -325,7 +386,7 @@ var (
 		Final:     '\ufef8'}
 )
 
-var arabic_alphabet = map[rune]Harf{}
+var arabicAlphabet = map[rune]Harf{}
 
 var arabicAlphabetCollection = []Harf{
 	ALEF_HAMZA_ABOVE,
@@ -378,11 +439,11 @@ var arabicAlphabetCollection = []Harf{
 func init() {
 	for _, harf := range arabicAlphabetCollection {
 		// Map all forms to the Harf struct
-		arabic_alphabet[harf.Unicode] = harf
-		arabic_alphabet[harf.Isolated] = harf
-		arabic_alphabet[harf.Beginning] = harf
-		arabic_alphabet[harf.Middle] = harf
-		arabic_alphabet[harf.Final] = harf
+		arabicAlphabet[harf.Unicode] = harf
+		arabicAlphabet[harf.Isolated] = harf
+		arabicAlphabet[harf.Beginning] = harf
+		arabicAlphabet[harf.Middle] = harf
+		arabicAlphabet[harf.Final] = harf
 	}
 }
 

arabic_helper.go

@@ -1,15 +1,56 @@
 package gopdf
 
-func Reverse(s string) string {
-	r := []rune(s)
-	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
-		r[i], r[j] = r[j], r[i]
-	}
-	return string(r)
+import "strings"
+
+// ALLAH_LIGATURE is the Unicode character for the Allah ligature (U+FDF2 ﷲ)
+const ALLAH_LIGATURE rune = 0xFDF2
+
+// convertAllahToLigature replaces the word "الله" (Allah) with the Allah ligature U+FDF2 (ﷲ)
+func convertAllahToLigature(text string) string {
+	// الله without tashkeel: Alef + Lam + Lam + Heh
+	allah := string([]rune{ALEF.Unicode, LAM.Unicode, LAM.Unicode, HEH.Unicode})
+	// Replace with the Allah ligature character
+	return strings.ReplaceAll(text, allah, string(ALLAH_LIGATURE))
 }
 
+// reverseWithTashkeel reverses Arabic text while keeping tashkeel attached to base characters
+func reverseWithTashkeel(runes []rune) string {
+	if len(runes) == 0 {
+		return ""
+	}
+
+	// Group base characters with their following tashkeel
+	type hrofGroup struct {
+		base     rune
+		tashkeel []rune
+	}
+
+	var groups []hrofGroup
+	var currentGroup *hrofGroup
+
+	for _, r := range runes {
+		if IsTashkeel(r) {
+			if currentGroup != nil {
+				currentGroup.tashkeel = append(currentGroup.tashkeel, r)
+			}
+		} else {
+			groups = append(groups, hrofGroup{base: r})
+			currentGroup = &groups[len(groups)-1]
+		}
+	}
+
+	// Reverse the groups and rebuild
+	// Output tashkeel BEFORE base for proper RTL rendering in PDF
+	result := make([]rune, 0, len(runes))
+	for i := len(groups) - 1; i >= 0; i-- {
+		result = append(result, groups[i].tashkeel...)
+		result = append(result, groups[i].base)
+	}
+	return string(result)
+
+}
 func getHarf(char rune) Harf {
-	for _, s := range arabic_alphabet {
+	for _, s := range arabicAlphabet {
 		if s.equals(char) {
 			return s
 		}
@@ -42,15 +83,15 @@ func getCharShape(previousChar, currentChar, nextChar rune) rune {
 	nextArabic := false
 	previousArabic := false
 
-	if _, ok := arabic_alphabet[previousChar]; ok {
+	if _, ok := arabicAlphabet[previousChar]; ok {
 		previousArabic = true
 	}
 
-	if _, ok := arabic_alphabet[nextChar]; ok {
+	if _, ok := arabicAlphabet[nextChar]; ok {
 		nextArabic = true
 	}
 
-	if _, ok := arabic_alphabet[currentChar]; !ok {
+	if _, ok := arabicAlphabet[currentChar]; !ok {
 		return shape
 	}
 
@@ -83,8 +124,34 @@ func getCharShape(previousChar, currentChar, nextChar rune) rune {
 	return shape
 }
 
+// findPreviousNonTashkeel finds the previous character that is not a tashkeel mark
+func findPreviousNonTashkeelHarf(runes []rune, currentIndex int) rune {
+	for i := currentIndex - 1; i >= 0; i-- {
+		if !IsTashkeel(runes[i]) {
+			return runes[i]
+		}
+	}
+	return 0
+}
+
+// findNextNonTashkeel finds the next character that is not a tashkeel mark
+func findNextNonTashkeelHarf(runes []rune, currentIndex int) rune {
+	for i := currentIndex + 1; i < len(runes); i++ {
+		if !IsTashkeel(runes[i]) {
+			return runes[i]
+		}
+	}
+	return 0
+}
+
+// IsTashkeel returns true if the rune is an Arabic diacritical mark
+func IsTashkeel(r rune) bool {
+	return tashkeelMarks[r]
+}
+
 func ToArabic(text string) string {
-	var nextHarf, previousHarf rune
+	// Preprocess: convert "الله" to the Allah ligature U+FDF2 (ﷲ)
+	text = convertAllahToLigature(text)
 
 	hrof := []rune(text)    // hrof is arabic letters
 	hrofLength := len(hrof) // hrof length is the number of arabic letters
@@ -93,17 +160,24 @@ func ToArabic(text string) string {
 	for i := 0; i < hrofLength; i++ {
 		currentHarf := hrof[i]
 
-		if i == 0 {
-			previousHarf = 0
-		} else {
-			previousHarf = hrof[i-1]
+		// If current char is tashkeel
+		if IsTashkeel(currentHarf) {
+			// Check if vowel followed by SHADDA - output combined ligature
+			if i+1 < hrofLength && hrof[i+1] == SHADDA && currentHarf != SHADDA {
+				if ligature := GetShaddaLigature(currentHarf); ligature != 0 {
+					arabicSentence = append(arabicSentence, ligature)
+					i++ // skip the shadda we already added
+					continue
+				}
+			}
+			arabicSentence = append(arabicSentence, currentHarf)
+			continue
 		}
+		// Find previous non-tashkeel character
+		previousHarf := findPreviousNonTashkeelHarf(hrof, i)
 
-		if i == hrofLength-1 {
-			nextHarf = 0
-		} else {
-			nextHarf = hrof[i+1]
-		}
+		// Find next non-tashkeel character
+		nextHarf := findNextNonTashkeelHarf(hrof, i)
 
 		// Lam-Alef Ligature Check
 		if currentHarf == LAM.Unicode && nextHarf != 0 {
@@ -119,19 +193,26 @@ func ToArabic(text string) string {
 			}
 			if foundLigature {
 				currentHarf = ligatureHarf
-				i++
-				// We need to update nextHarf to the one *after* the Alef for correct shaping of the ligature itself
-				if i == hrofLength-1 {
-					nextHarf = 0
-				} else {
-					nextHarf = hrof[i+1]
+				// Collect tashkeel between Lam and Alef
+				var tashkeelBetween []rune
+				for i++; i < hrofLength && hrof[i] != nextHarf; i++ {
+					if IsTashkeel(hrof[i]) {
+						tashkeelBetween = append(tashkeelBetween, hrof[i])
+					}
 				}
+				nextHarf = findNextNonTashkeelHarf(hrof, i)
+
+				// Append ligature shape first, then tashkeel (so tashkeel attaches to ligature after reversal)
+				harfShape := getCharShape(previousHarf, currentHarf, nextHarf)
+				arabicSentence = append(arabicSentence, harfShape)
+				arabicSentence = append(arabicSentence, tashkeelBetween...)
+				continue
 			}
 		}
 
 		harfShape := getCharShape(previousHarf, currentHarf, nextHarf)
 		arabicSentence = append(arabicSentence, harfShape)
 	}
-	arabicSentenceRTL := Reverse(string(arabicSentence))
+	arabicSentenceRTL := reverseWithTashkeel(arabicSentence)
 	return arabicSentenceRTL
 }