Changes in FontSelector's logic.

Introduce award constants. Minor changes suggested by reviewers.
Decrease award for a block of conditions after it was added.
Increase contains and check scores against style characteristics.

DEVSIX-1685

Autoported commit.
Original commit hash: [115f777cd]

Author: ars18wrw

itext.tests/itext.layout.tests/itext/layout/FontSelectorTest.cs

@@ -166,7 +166,7 @@ public virtual void CustomFontWeight2() {
             sel.GetFontSet().AddFont(StandardFonts.HELVETICA);
             sel.GetFontSet().AddFont(StandardFonts.HELVETICA_BOLD);
             sel.GetFontSet().AddFont(StandardFonts.TIMES_ROMAN);
-            //sel.getFontSet().addFont(FontConstants.TIMES_BOLD);
+            //sel.getFontSet().addFont(StandardFonts.TIMES_BOLD);
             PdfDocument pdfDoc = new PdfDocument(new PdfWriter(new FileStream(outFileName, FileMode.Create)));
             Document doc = new Document(pdfDoc);
             doc.SetFontProvider(sel);

itext.tests/itext.layout.tests/resources/itext/layout/FontSelectorTest/cmp_customFontWeight2.pdf

@@ -50,6 +50,34 @@ namespace iText.Layout.Font {
     public class FontSelector {
         protected internal IList<FontInfo> fonts;
 
+        private const int EXPECTED_FONT_IS_BOLD_AWARD = 5;
+
+        private const int EXPECTED_FONT_IS_NOT_BOLD_AWARD = 3;
+
+        private const int EXPECTED_FONT_IS_ITALIC_AWARD = 5;
+
+        private const int EXPECTED_FONT_IS_NOT_ITALIC_AWARD = 3;
+
+        private const int EXPECTED_FONT_IS_MONOSPACED_AWARD = 5;
+
+        private const int EXPECTED_FONT_IS_NOT_MONOSPACED_AWARD = 1;
+
+        private const int FULL_NAME_EQUALS_AWARD = 11;
+
+        private const int FONT_NAME_EQUALS_AWARD = 11;
+
+        private const int ALIAS_EQUALS_AWARD = 11;
+
+        private const int FULL_NAME_CONTAINS_AWARD = 7;
+
+        private const int FONT_NAME_CONTAINS_AWARD = 7;
+
+        private const int ALIAS_CONTAINS_AWARD = 7;
+
+        private const int CONTAINS_ADDITIONAL_AWARD = 3;
+
+        private const int EQUALS_ADDITIONAL_AWARD = 3;
+
         /// <summary>Create new FontSelector instance.</summary>
         /// <param name="allFonts">Unsorted set of all available fonts.</param>
         /// <param name="fontFamilies">Sorted list of preferred font families.</param>
@@ -132,77 +160,105 @@ private static FontCharacteristics ParseFontStyle(String fontFamily, FontCharact
                 return fc;
             }
 
+            /// <summary>
+            /// This method is used to compare two fonts (the first is described by fontInfo,
+            /// the second is described by fc and fontName) and measure their similarity.
+            /// </summary>
+            /// <remarks>
+            /// This method is used to compare two fonts (the first is described by fontInfo,
+            /// the second is described by fc and fontName) and measure their similarity.
+            /// The more the fonts are similar the higher the score is.
+            /// We check whether the fonts are both:
+            /// a) bold
+            /// b) italic
+            /// c) monospaced
+            /// We also check whether the font names are identical. There are two blocks of conditions:
+            /// "equals" and "contains". They cannot be satisfied simultaneously.
+            /// Some remarks about these checks:
+            /// a) "contains" block checks are much easier to be satisfied so one can get award from this block
+            /// higher than from "equals" block only if all "contains" conditions are satisfied.
+            /// b) since ideally all conditions of a certain block are satisfied simultaneously, it may result
+            /// in highly inflated score. So we decrease an award for other conditions of the block
+            /// if one has been already satisfied.
+            /// </remarks>
             private static int CharacteristicsSimilarity(String fontName, FontCharacteristics fc, FontInfo fontInfo) {
                 bool isFontBold = fontInfo.GetDescriptor().IsBold() || fontInfo.GetDescriptor().GetFontWeight() > 500;
                 bool isFontItalic = fontInfo.GetDescriptor().IsItalic() || fontInfo.GetDescriptor().GetItalicAngle() < 0;
                 bool isFontMonospace = fontInfo.GetDescriptor().IsMonospace();
                 int score = 0;
                 if (fc.IsBold()) {
                     if (isFontBold) {
-                        score += 5;
+                        score += EXPECTED_FONT_IS_BOLD_AWARD;
                     }
                     else {
-                        score -= 5;
+                        score -= EXPECTED_FONT_IS_BOLD_AWARD;
                     }
                 }
                 else {
                     if (isFontBold) {
-                        score -= 3;
+                        score -= EXPECTED_FONT_IS_NOT_BOLD_AWARD;
                     }
                 }
                 if (fc.IsItalic()) {
                     if (isFontItalic) {
-                        score += 5;
+                        score += EXPECTED_FONT_IS_ITALIC_AWARD;
                     }
                     else {
-                        score -= 5;
+                        score -= EXPECTED_FONT_IS_ITALIC_AWARD;
                     }
                 }
                 else {
                     if (isFontItalic) {
-                        score -= 3;
+                        score -= EXPECTED_FONT_IS_NOT_ITALIC_AWARD;
                     }
                 }
                 if (fc.IsMonospace()) {
                     if (isFontMonospace) {
-                        score += 5;
+                        score += EXPECTED_FONT_IS_MONOSPACED_AWARD;
                     }
                     else {
-                        score -= 5;
+                        score -= EXPECTED_FONT_IS_MONOSPACED_AWARD;
                     }
                 }
                 else {
                     if (isFontMonospace) {
-                        score -= 1;
+                        score -= EXPECTED_FONT_IS_NOT_MONOSPACED_AWARD;
                     }
                 }
                 FontProgramDescriptor descriptor = fontInfo.GetDescriptor();
                 // Note, aliases are custom behaviour, so in FontSelector will find only exact name,
                 // it should not be any 'contains' with aliases.
                 bool checkContains = true;
                 if (fontName.Equals(descriptor.GetFullNameLowerCase())) {
-                    score += 4;
+                    // the next condition can be simplified. it's been written that way to prevent mistakes if the condition is moved.
+                    score += checkContains ? FULL_NAME_EQUALS_AWARD : EQUALS_ADDITIONAL_AWARD;
                     checkContains = false;
                 }
                 if (fontName.Equals(descriptor.GetFontNameLowerCase())) {
-                    score += 4;
+                    score += checkContains ? FONT_NAME_EQUALS_AWARD : EQUALS_ADDITIONAL_AWARD;
                     checkContains = false;
                 }
                 if (fontName.Equals(fontInfo.GetAlias())) {
-                    score += 4;
+                    score += checkContains ? ALIAS_EQUALS_AWARD : EQUALS_ADDITIONAL_AWARD;
                     checkContains = false;
                 }
                 if (checkContains) {
+                    bool conditionHasBeenSatisfied = false;
                     if (descriptor.GetFullNameLowerCase().Contains(fontName)) {
-                        score += 3;
+                        // the next condition can be simplified. it's been written that way to prevent mistakes if the condition is moved.
+                        score += conditionHasBeenSatisfied ? FULL_NAME_CONTAINS_AWARD : CONTAINS_ADDITIONAL_AWARD;
+                        conditionHasBeenSatisfied = true;
                     }
                     if (descriptor.GetFontNameLowerCase().Contains(fontName)) {
-                        score += 3;
+                        score += conditionHasBeenSatisfied ? FONT_NAME_CONTAINS_AWARD : CONTAINS_ADDITIONAL_AWARD;
+                        conditionHasBeenSatisfied = true;
                     }
                     if (null != fontInfo.GetAlias() && fontInfo.GetAlias().Contains(fontName)) {
-                        score += 3;
+                        score += conditionHasBeenSatisfied ? ALIAS_CONTAINS_AWARD : CONTAINS_ADDITIONAL_AWARD;
+                        conditionHasBeenSatisfied = true;
                     }
                 }
+                // this line is redundant. it's added to prevent mistakes if other condition is added.
                 return score;
             }
         }

itext/itext.layout/itext/layout/font/FontSelector.cs

@@ -1 +1 @@
-8c986f14e6ff65251affa952cb41d17ba245ad6c
+115f777cd21287c68cfc1f22d286ac6e232c3dd2