Ticket #11518: 0001-Implementation-of-BFont-Blocks.patch

build/jam/BuildFeatures

@@ -303 +303 @@
     Echo "Freetype support not available on $(TARGET_PACKAGING_ARCH)" ;
 }
 
+# fontconfig
+if [ IsPackageAvailable fontconfig_devel ] {
+    ExtractBuildFeatureArchives fontconfig :
+        file: base fontconfig
+            runtime: lib
+        file: devel fontconfig_devel
+            depends: base
+            library: $(developLibDir)/libfontconfig.so
+            headers: $(developHeadersDir) $(developHeadersDir)/fontconfig
+        ;
+
+    EnableBuildFeatures fontconfig ;
+} else {
+    Echo "fontconfig support not available on $(TARGET_PACKAGING_ARCH)" ;
+}
 
 # Gutenprint
 if [ IsPackageAvailable gutenprint_devel ] {

build/jam/OptionalPackages

@@ -100 +100 @@
     local architectureObject ;
     for architectureObject in [ MultiArchSubDirSetup ] {
         on $(architectureObject) {
-            AddHaikuImagePackages curl_devel ffmpeg_devel freetype_devel
-                glu_devel jpeg_devel libpng16_devel zlib_devel ;
+            AddHaikuImagePackages curl_devel ffmpeg_devel fontconfig_devel 
+                freetype_devel glu_devel jpeg_devel libpng16_devel zlib_devel ;
         }
     }
 }

headers/os/interface/Font.h

@@ -1 +1 @@
 /*
- * Copyright 2005-2015, Haiku, Inc. All rights reserved.
+ * Copyright 2005-2016, Haiku, Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  */
 #ifndef _FONT_H_
@@ -120 +120 @@
 };
 
 
+struct unicode_block_range {
+    uint32                  start;
+    uint32                  end;
+    const unicode_block&    block;
+
+    uint32 Count() const { return end + 1 - start; }
+};
+
+
 struct edge_info {
     float   left;
     float   right;
@@ -201 +210 @@
             bool                IsFullAndHalfFixed() const;
             BRect               BoundingBox() const;
             unicode_block       Blocks() const;
+            bool                IncludesBlock(uint32 start, uint32 end) const;
             font_file_format    FileFormat() const;
 
             int32               CountTuned() const;
@@ -371 +381 @@
 {
     fData[0] = block.fData[0];
     fData[1] = block.fData[1];
+
     return *this;
 }
 

headers/os/interface/UnicodeBlockObjects.h

@@ -1 +1 @@
 /*
- * Copyright 2001-2009, Haiku, Inc. All rights reserved.
+ * Copyright 2001-2016, Haiku, Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  */
 #ifndef _UNICODEBLOCKOBJECTS_H
@@ -10 +10 @@
 
 
 // Unicode block list with their unicode encoding range
+//
+// Original BeOS-compatible blocks
 const unicode_block B_BASIC_LATIN_BLOCK(                    /* 0000 - 007F          */  0x0000000000000000LL, 0x0000000000000001LL);
 const unicode_block B_LATIN1_SUPPLEMENT_BLOCK(              /* 0080 - 00FF          */  0x0000000000000000LL, 0x0000000000000002LL);
 const unicode_block B_LATIN_EXTENDED_A_BLOCK(               /* 0100 - 017F          */  0x0000000000000000LL, 0x0000000000000004LL);
@@ -82 +84 @@
 const unicode_block B_SPECIALS_BLOCK(                       /* FEFF and FFF0 - FFFF */  0x0000000000000020LL, 0x0000000000000000LL);
 const unicode_block B_TIBETAN_BLOCK(                        /* 0F00 - 0FBF          */  0x0000000000000040LL, 0x0000000000000000LL);
 
+
+const unicode_block_range kUnicodeBlockMap[] = {
+    {0x0000, 0x007f, B_BASIC_LATIN_BLOCK },
+    {0x0080, 0x00ff, B_LATIN1_SUPPLEMENT_BLOCK },
+    {0x0100, 0x017f, B_LATIN_EXTENDED_A_BLOCK },
+    {0x0180, 0x024f, B_LATIN_EXTENDED_B_BLOCK },
+    {0x0250, 0x02af, B_IPA_EXTENSIONS_BLOCK },
+    {0x02b0, 0x02ff, B_SPACING_MODIFIER_LETTERS_BLOCK },
+    {0x0300, 0x036f, B_COMBINING_DIACRITICAL_MARKS_BLOCK },
+    {0x0370, 0x03cf, B_BASIC_GREEK_BLOCK },
+    {0x03d0, 0x03ff, B_GREEK_SYMBOLS_AND_COPTIC_BLOCK },
+    {0x0400, 0x04ff, B_CYRILLIC_BLOCK },
+    {0x0530, 0x058f, B_ARMENIAN_BLOCK },
+    {0x0590, 0x05cf, B_BASIC_HEBREW_BLOCK },
+    {0x05d0, 0x05ff, B_HEBREW_EXTENDED_BLOCK },
+    {0x0600, 0x0670, B_BASIC_ARABIC_BLOCK },
+    {0x0671, 0x06ff, B_ARABIC_EXTENDED_BLOCK },
+    {0x0900, 0x097f, B_DEVANAGARI_BLOCK },
+    {0x0980, 0x09ff, B_BENGALI_BLOCK },
+    {0x0a00, 0x0a7f, B_GURMUKHI_BLOCK },
+    {0x0a80, 0x0aff, B_GUJARATI_BLOCK },
+    {0x0b00, 0x0b7f, B_ORIYA_BLOCK },
+    {0x0b80, 0x0bff, B_TAMIL_BLOCK },
+    {0x0c00, 0x0c7f, B_TELUGU_BLOCK },
+    {0x0c80, 0x0cff, B_KANNADA_BLOCK},
+    {0x0d00, 0x0d7f, B_MALAYALAM_BLOCK},
+    {0x0e00, 0x0e7f, B_THAI_BLOCK},
+    {0x0e80, 0x0eff, B_LAO_BLOCK},
+    {0x0f00, 0x0fff, B_TIBETAN_BLOCK},
+    {0x10a0, 0x10ff, B_BASIC_GEORGIAN_BLOCK},
+    {0x1100, 0x11ff, B_HANGUL_JAMO_BLOCK},
+    {0x1e00, 0x1eff, B_LATIN_EXTENDED_ADDITIONAL_BLOCK},
+    {0x1f00, 0x1fff, B_GREEK_EXTENDED_BLOCK},
+    {0x2000, 0x206f, B_GENERAL_PUNCTUATION_BLOCK},
+    {0x2070, 0x209f, B_SUPERSCRIPTS_AND_SUBSCRIPTS_BLOCK},
+    {0x20a0, 0x20cf, B_CURRENCY_SYMBOLS_BLOCK},
+    {0x20d0, 0x20ff, B_COMBINING_MARKS_FOR_SYMBOLS_BLOCK},
+    {0x2100, 0x214f, B_LETTERLIKE_SYMBOLS_BLOCK},
+    {0x2150, 0x218f, B_NUMBER_FORMS_BLOCK},
+    {0x2190, 0x21ff, B_ARROWS_BLOCK},
+    {0x2200, 0x22ff, B_MATHEMATICAL_OPERATORS_BLOCK},
+    {0x2300, 0x23ff, B_MISCELLANEOUS_TECHNICAL_BLOCK},
+    {0x2400, 0x243f, B_CONTROL_PICTURES_BLOCK},
+    {0x2440, 0x245f, B_OPTICAL_CHARACTER_RECOGNITION_BLOCK},
+    {0x2460, 0x24ff, B_ENCLOSED_ALPHANUMERICS_BLOCK},
+    {0x2500, 0x257f, B_BOX_DRAWING_BLOCK},
+    {0x2580, 0x259f, B_BLOCK_ELEMENTS_BLOCK},
+    {0x25a0, 0x25ff, B_GEOMETRIC_SHAPES_BLOCK},
+    {0x2600, 0x26ff, B_MISCELLANEOUS_SYMBOLS_BLOCK},
+    {0x2700, 0x27bf, B_DINGBATS_BLOCK},
+    {0x3000, 0x303f, B_CJK_SYMBOLS_AND_PUNCTUATION_BLOCK},
+    {0x3040, 0x309f, B_HIRAGANA_BLOCK},
+    {0x30a0, 0x30ff, B_KATAKANA_BLOCK},
+    {0x3100, 0x312f, B_BOPOMOFO_BLOCK},
+    {0x3130, 0x318f, B_HANGUL_COMPATIBILITY_JAMO_BLOCK},
+    {0x3190, 0x319f, B_CJK_MISCELLANEOUS_BLOCK},
+    {0x3200, 0x32ff, B_ENCLOSED_CJK_LETTERS_AND_MONTHS_BLOCK},
+    {0x3300, 0x33ff, B_CJK_COMPATIBILITY_BLOCK},
+    {0x4e00, 0x9fff, B_CJK_UNIFIED_IDEOGRAPHS_BLOCK},
+    {0xd800, 0xdb7f, B_HIGH_SURROGATES_BLOCK},
+    {0xdc00, 0xdfff, B_LOW_SURROGATES_BLOCK},
+    {0xe000, 0xf8ff, B_PRIVATE_USE_AREA_BLOCK},
+    {0xf900, 0xfaff, B_CJK_COMPATIBILITY_IDEOGRAPHS_BLOCK},
+    {0xfb00, 0xfb4f, B_ALPHABETIC_PRESENTATION_FORMS_BLOCK},
+    {0xfb50, 0xfdff, B_ARABIC_PRESENTATION_FORMS_A_BLOCK},
+    {0xfe20, 0xfe2f, B_COMBINING_HALF_MARKS_BLOCK},
+    {0xfe30, 0xfe4f, B_CJK_COMPATIBILITY_FORMS_BLOCK},
+    {0xfe50, 0xfe6f, B_SMALL_FORM_VARIANTS_BLOCK},
+    {0xfe70, 0xfeff, B_ARABIC_PRESENTATION_FORMS_B_BLOCK},
+    {0xff00, 0xffef, B_HALFWIDTH_AND_FULLWIDTH_FORMS_BLOCK},
+    {0xfff0, 0xffff, B_SPECIALS_BLOCK}
+};
+
+const uint32 kNumUnicodeBlockRanges
+    = sizeof(kUnicodeBlockMap) / sizeof(kUnicodeBlockMap[0]);
+
 #endif  // _UNICODEBLOCKOBJECTS_H

headers/private/app/ServerProtocol.h

@@ -1 +1 @@
 /*
- * Copyright 2001-2015, Haiku.
+ * Copyright 2001-2016, Haiku.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -143 +143 @@
     AS_GET_HAS_GLYPHS,
     AS_GET_GLYPH_SHAPES,
     AS_GET_TRUNCATED_STRINGS,
+    AS_GET_UNICODE_BLOCKS,
+    AS_GET_HAS_UNICODE_BLOCK,
 
     // Screen methods
     AS_VALID_SCREEN_ID,

src/kits/interface/Font.cpp

@@ -839 +839 @@
 unicode_block
 BFont::Blocks() const
 {
-    // TODO: Add Block support
-    return unicode_block(~0LL, ~0LL);
+    BPrivate::AppServerLink link;
+    link.StartMessage(AS_GET_UNICODE_BLOCKS);
+    link.Attach<uint16>(fFamilyID);
+    link.Attach<uint16>(fStyleID);
+    
+    int32 status;
+    if (link.FlushWithReply(status) != B_OK 
+        || status != B_OK) {
+        return unicode_block(~0LL, ~0LL);
+    }
+    
+    unicode_block blocksForFont;
+    link.Read<unicode_block>(&blocksForFont);
+    
+    return blocksForFont;
+}
+
+bool
+BFont::IncludesBlock(uint32 start, uint32 end) const
+{
+    BPrivate::AppServerLink link;
+    link.StartMessage(AS_GET_HAS_UNICODE_BLOCK);
+    link.Attach<uint16>(fFamilyID);
+    link.Attach<uint16>(fStyleID);
+    link.Attach<uint32>(start);
+    link.Attach<uint32>(end);
+    
+    int32 status;
+    if (link.FlushWithReply(status) != B_OK 
+        || status != B_OK) {
+        return false;
+    }
+    
+    bool hasBlock;
+    link.Read<bool>(&hasBlock);
+
+    return hasBlock;
 }
 
 

src/servers/app/Jamfile

@@ -32 +32 @@
     ;
 
 UseBuildFeatureHeaders freetype ;
-Includes [ FGristFiles AppServer.cpp BitmapManager.cpp Canvas.cpp
+if [ FIsBuildFeatureEnabled fontconfig ] {
+    SubDirC++Flags -DFONTCONFIG_ENABLED ;
+    UseBuildFeatureHeaders fontconfig ;
+    Includes [ FGristFiles AppServer.cpp BitmapManager.cpp Canvas.cpp
+    ClientMemoryAllocator.cpp Desktop.cpp DesktopSettings.cpp
+    DrawState.cpp DrawingEngine.cpp Layer.cpp PictureBoundingBoxPlayer.cpp
+    ServerApp.cpp ServerBitmap.cpp ServerCursor.cpp ServerFont.cpp
+    ServerPicture.cpp ServerWindow.cpp View.cpp Window.cpp WorkspacesView.cpp
+    $(decorator_src) $(font_src) ]
+    : [ BuildFeatureAttribute freetype : headers ]
+      [ BuildFeatureAttribute fontconfig : headers ] ;
+} else {
+    Includes [ FGristFiles AppServer.cpp BitmapManager.cpp Canvas.cpp
     ClientMemoryAllocator.cpp Desktop.cpp DesktopSettings.cpp
     DrawState.cpp DrawingEngine.cpp Layer.cpp PictureBoundingBoxPlayer.cpp
     ServerApp.cpp ServerBitmap.cpp ServerCursor.cpp ServerFont.cpp
     ServerPicture.cpp ServerWindow.cpp View.cpp Window.cpp WorkspacesView.cpp
     $(decorator_src) $(font_src) ]
     : [ BuildFeatureAttribute freetype : headers ] ;
-
+}
 
 local BROKEN_64 = ;
 if $(TARGET_ARCH) != x86_64 {
@@ -103 +115 @@
     libaslocal.a $(BROKEN_64)libasremote.a $(BROKEN_64)libashtml5.a
     libasdrawing.a libpainter.a libagg.a
     [ BuildFeatureAttribute freetype : library ]
+    [ BuildFeatureAttribute fontconfig : library ]
     libstackandtile.a liblinprog.a libtextencoding.so shared
     [ TargetLibstdc++ ]
 

src/servers/app/ProfileMessageSupport.cpp

@@ -1 +1 @@
 /*
- * Copyright 2007-2009, Haiku Inc. All rights reserved.
+ * Copyright 2007-2016, Haiku Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -125 +125 @@
         CODE(AS_GET_HAS_GLYPHS);
         CODE(AS_GET_GLYPH_SHAPES);
         CODE(AS_GET_TRUNCATED_STRINGS);
+        CODE(AS_GET_UNICODE_BLOCKS);
+        CODE(AS_GET_HAS_UNICODE_BLOCK);
 
         // Screen methods
         CODE(AS_VALID_SCREEN_ID);

src/servers/app/ServerApp.cpp

@@ -2028 +2028 @@
             break;
         }
 
+        case AS_GET_UNICODE_BLOCKS:
+        {
+            FTRACE(("ServerApp %s: AS_GET_UNICODE_BLOCKS\n", Signature()));
+            
+            // Attached Data:
+            // 1) uint16 family ID
+            // 2) uint16 style ID
+            
+            // Returns:
+            // 1) unicode_block - bitfield of Unicode blocks in font
+
+            uint16 familyID, styleID;
+            link.Read<uint16>(&familyID);
+            link.Read<uint16>(&styleID);
+            
+            ServerFont font;
+            status_t status = font.SetFamilyAndStyle(familyID, styleID);
+            if (status == B_OK) {
+                unicode_block blocksForFont;
+                font.GetUnicodeBlocks(blocksForFont);
+                
+                fLink.StartMessage(B_OK);
+                fLink.Attach<unicode_block>(blocksForFont);
+            } else
+                fLink.StartMessage(status);
+
+            fLink.Flush();
+            break;
+        }
+            
+        case AS_GET_HAS_UNICODE_BLOCK:
+        {
+            FTRACE(("ServerApp %s: AS_INCLUDES_UNICODE_BLOCK\n", Signature()));
+            
+            // Attached Data:
+            // 1) uint16 family ID
+            // 2) uint16 style ID
+            // 3 uint32 start of unicode block
+            // 4) uint32 end of unicode block
+            
+            // Returns:
+            // 1) bool - whether or not font includes specified block range
+
+            uint16 familyID, styleID;
+            uint32 start, end;
+            link.Read<uint16>(&familyID);
+            link.Read<uint16>(&styleID);
+            link.Read<uint32>(&start);
+            link.Read<uint32>(&end);
+            
+            ServerFont font;
+            status_t status = font.SetFamilyAndStyle(familyID, styleID);
+            if (status == B_OK) {
+                bool hasBlock;
+                
+                status = font.IncludesUnicodeBlock(start, end, hasBlock); 
+                fLink.StartMessage(status);
+                fLink.Attach<bool>(hasBlock);
+            } else
+                fLink.StartMessage(status);
+
+            fLink.Flush();
+            break;
+        }
+        
         case AS_GET_GLYPH_SHAPES:
         {
             FTRACE(("ServerApp %s: AS_GET_GLYPH_SHAPES\n", Signature()));

src/servers/app/ServerFont.cpp

@@ -22 +22 @@
 #include FT_GLYPH_H
 #include FT_OUTLINE_H
 
+#ifdef FONTCONFIG_ENABLED
+
+#include <fontconfig.h>
+#include <fcfreetype.h>
+
+#endif // FONTCONFIG_ENABLED
+
 #include <Shape.h>
 #include <String.h>
+#include <UnicodeBlockObjects.h>
 #include <UTF8.h>
 
 #include <agg_bounding_rect.h>
@@ -437 +445 @@
 }
 
 
+#ifdef FONTCONFIG_ENABLED
+
+/*!
+    \brief For a given codepoint, do a binary search of the defined unicode
+    blocks to figure out which one contains the codepoint.
+    \param codePoint is the point to find
+    \param startGuess is the starting point for the binary search (default 0)
+*/
+static
+int32
+FindBlockForCodepoint(uint32 codePoint, uint32 startGuess)
+{
+    uint32 min = 0;
+    uint32 max = kNumUnicodeBlockRanges;
+    uint32 guess = (max + min) / 2;
+
+    if (startGuess > 0)
+        guess = startGuess;
+
+    if (codePoint > kUnicodeBlockMap[max-1].end)
+        return -1;
+
+    while ((max >= min) && (guess < kNumUnicodeBlockRanges)) {
+        uint32 start = kUnicodeBlockMap[guess].start;
+        uint32 end = kUnicodeBlockMap[guess].end;
+
+        if (start <= codePoint && end >= codePoint)
+            return guess;
+
+        if (end < codePoint) {
+            min = guess + 1;
+        } else {
+            max = guess - 1;
+        }
+
+        guess = (max + min) / 2;
+    }
+
+    return -1;
+}
+
+/*!
+    \brief parses charmap from fontconfig.  See fontconfig docs for FcCharSetFirstPage
+    and FcCharSetNextPage for details on format.
+    \param charMap is a fontconfig character map
+    \param baseCodePoint is the base codepoint returned by fontconfig
+    \param blocksForMap is a unicode_block to store the bitmap of contained blocks
+*/
+static
+void
+ParseFcMap(FcChar32 charMap[], FcChar32 baseCodePoint, unicode_block& blocksForMap)
+{
+    for (int i = 0; i < FC_CHARSET_MAP_SIZE; ++i) {
+        FcChar32 curMapBlock = charMap[i];
+        uint32 rangeStart = 0;
+        uint32 block = 0;
+
+        for (int bit = 0; bit < 32; ++bit) {
+            uint32 startPoint = 0;
+            int32 foundStartBlock = -1;
+            int32 foundEndBlock = -1;
+
+            if ((curMapBlock & 0x8) != 0) {
+                if (rangeStart == 0) {
+                    rangeStart = bit;
+                    startPoint = baseCodePoint + block + (rangeStart);
+                    foundStartBlock = FindBlockForCodepoint(startPoint, 0);
+                    if (foundStartBlock >= 0) {
+                        blocksForMap = blocksForMap
+                            | kUnicodeBlockMap[foundStartBlock].block;
+                    }
+                }
+            } else if (rangeStart > 0 && foundStartBlock > 0) {
+                    // when we find an empty bit, that's the end of the range
+                uint32 endPoint = baseCodePoint + block + (bit - 1);
+
+                foundEndBlock = FindBlockForCodepoint(endPoint,
+                    foundStartBlock);
+                    // start the binary search at the block where we found the
+                    // start codepoint to ideally find the end in the same
+                    // block.
+                ++foundStartBlock;
+
+                while (foundStartBlock <= foundEndBlock) {
+                    // if the starting codepoint is found in a different block
+                    // than the ending codepoint, we should add all the blocks
+                    // inbetween.
+                    blocksForMap = blocksForMap
+                        | kUnicodeBlockMap[foundStartBlock].block;
+                    ++foundStartBlock;
+                }
+
+                foundStartBlock = -1;
+                foundEndBlock = -1;
+                rangeStart = 0;
+            } else {
+                foundStartBlock = -1;
+                rangeStart = 0;
+            }
+
+            curMapBlock >>= 1;
+        }
+
+        block += 32;
+    }
+}
+
+#endif // FONTCONFIG_ENABLED
+
+
+/*!
+    \brief Gets a bitmap that indicates which Unicode blocks are in the font.
+    \param unicode_block to store bitmap in
+    \return B_OK; bitmap will be empty if something went wrong
+*/
+status_t
+ServerFont::GetUnicodeBlocks(unicode_block& blocksForFont)
+{
+    blocksForFont = unicode_block();
+
+#ifdef FONTCONFIG_ENABLED
+    FT_Face face = GetTransformedFace(true, true);
+    if (face == NULL)
+        return B_ERROR;
+
+    FcCharSet *charSet = FcFreeTypeCharSet(face, NULL);
+    if (charSet == NULL)
+        return B_ERROR;
+
+    FcChar32 charMap[FC_CHARSET_MAP_SIZE];
+    FcChar32 next = 0;
+    FcChar32 baseCodePoint = FcCharSetFirstPage(charSet, charMap, &next);
+
+    while ((baseCodePoint != FC_CHARSET_DONE) && (next != FC_CHARSET_DONE)) {
+        ParseFcMap(charMap, baseCodePoint, blocksForFont);
+        baseCodePoint = FcCharSetNextPage(charSet, charMap, &next);
+    }
+
+#endif // FONTCONFIG_ENABLED
+
+    return B_OK;
+}
+
+/*!
+    \brief Checks if a unicode block specified by a start and end point is defined
+    in the current font
+    \param start of unicode block
+    \param end of unicode block
+    \param hasBlock boolean to store whether the font contains the specified block
+    \return B_OK; hasBlock will be false if something goes wrong
+*/
+status_t
+ServerFont::IncludesUnicodeBlock(uint32 start, uint32 end, bool& hasBlock)
+{
+    hasBlock = false;
+
+#ifdef FONTCONFIG_ENABLED
+    FT_Face face = GetTransformedFace(true, true);
+    if (face == NULL)
+        return B_ERROR;
+
+    FcCharSet *charSet = FcFreeTypeCharSet(face, NULL);
+    if (charSet == NULL)
+        return B_ERROR;
+
+    uint32 curCodePoint = start;
+
+    while (curCodePoint <= end && hasBlock == false) {
+        // loop through range; if any character in the range is in the charset
+        // then the block is represented.
+        if (FcCharSetHasChar(charSet, (FcChar32)curCodePoint) == FcTrue) {
+            hasBlock = true;
+            break;
+        }
+
+        ++curCodePoint;
+    }
+
+#endif // FONTCONFIG_ENABLED
+
+    return B_OK;
+}
+
+
 class HasGlyphsConsumer {
  public:
     HasGlyphsConsumer(bool* hasArray)

src/servers/app/ServerFont.h

@@ -163 +163 @@
                                                float width) const;
 
             Transformable       EmbeddedTransformation() const;
+            status_t            GetUnicodeBlocks(unicode_block &blocksForFont);
+            status_t            IncludesUnicodeBlock(uint32 start, uint32 end, bool &hasBlock);
 
 protected:
     friend class FontStyle;