Home | History | Annotate | Download | only in fonts 
      1 /*
      2  * Copyright (C) 2006, 2007, 2008, 2013 Apple Inc. All rights reserved.
      3  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  *
      9  * 1.  Redistributions of source code must retain the above copyright
     10  *     notice, this list of conditions and the following disclaimer.
     11  * 2.  Redistributions in binary form must reproduce the above copyright
     12  *     notice, this list of conditions and the following disclaimer in the
     13  *     documentation and/or other materials provided with the distribution.
     14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
     15  *     its contributors may be used to endorse or promote products derived
     16  *     from this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
     19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
     22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
     25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     28  */
     29 
     30 #ifndef GlyphPage_h
     31 #define GlyphPage_h
     32 
     33 #include "platform/PlatformExport.h"
     34 #include "platform/fonts/CustomFontData.h"
     35 #include "platform/fonts/Glyph.h"
     36 #include <string.h>
     37 #include "wtf/PassRefPtr.h"
     38 #include "wtf/RefCounted.h"
     39 #include "wtf/RefPtr.h"
     40 #include "wtf/unicode/Unicode.h"
     41 
     42 namespace blink {
     43 
     44 class SimpleFontData;
     45 class GlyphPageTreeNode;
     46 
     47 // Holds the glyph index and the corresponding SimpleFontData information for a given
     48 // character.
     49 struct GlyphData {
     50     GlyphData(Glyph g = 0, const SimpleFontData* f = 0)
     51         : glyph(g)
     52         , fontData(f)
     53     {
     54     }
     55     Glyph glyph;
     56     const SimpleFontData* fontData;
     57 };
     58 
     59 #if COMPILER(MSVC)
     60 #pragma warning(push)
     61 #pragma warning(disable: 4200) // Disable "zero-sized array in struct/union" warning
     62 #endif
     63 
     64 // A GlyphPage contains a fixed-size set of GlyphData mappings for a contiguous
     65 // range of characters in the Unicode code space. GlyphPages are indexed
     66 // starting from 0 and incrementing for each 256 glyphs.
     67 //
     68 // One page may actually include glyphs from other fonts if the characters are
     69 // missing in the primary font. It is owned by exactly one GlyphPageTreeNode,
     70 // although multiple nodes may reference it as their "page" if they are supposed
     71 // to be overriding the parent's node, but provide no additional information.
     72 class PLATFORM_EXPORT GlyphPage : public RefCounted<GlyphPage> {
     73 public:
     74     static PassRefPtr<GlyphPage> createForMixedFontData(GlyphPageTreeNode* owner)
     75     {
     76         void* slot = fastMalloc(sizeof(GlyphPage) + sizeof(SimpleFontData*) * GlyphPage::size);
     77         return adoptRef(new (slot) GlyphPage(owner));
     78     }
     79 
     80     static PassRefPtr<GlyphPage> createForSingleFontData(GlyphPageTreeNode* owner, const SimpleFontData* fontData)
     81     {
     82         ASSERT(fontData);
     83         return adoptRef(new GlyphPage(owner, fontData));
     84     }
     85 
     86     PassRefPtr<GlyphPage> createCopiedSystemFallbackPage(GlyphPageTreeNode* owner) const
     87     {
     88         RefPtr<GlyphPage> page = GlyphPage::createForMixedFontData(owner);
     89         memcpy(page->m_glyphs, m_glyphs, sizeof(m_glyphs));
     90         if (hasPerGlyphFontData())
     91             memcpy(page->m_perGlyphFontData, m_perGlyphFontData, sizeof(SimpleFontData*) * GlyphPage::size);
     92         else {
     93             for (size_t i = 0; i < GlyphPage::size; ++i) {
     94                 page->m_perGlyphFontData[i] = m_glyphs[i] ? m_fontDataForAllGlyphs : 0;
     95             }
     96         }
     97         page->m_customFontToLoad = m_customFontToLoad;
     98         return page.release();
     99     }
    100 
    101     ~GlyphPage() { }
    102 
    103     static const unsigned char sizeBits = 8;
    104     static const size_t size = (1 << GlyphPage::sizeBits); // Covers Latin-1 in a single page.
    105     static unsigned indexForCharacter(UChar32 c) { return c & 0xFF; }
    106 
    107     ALWAYS_INLINE GlyphData glyphDataForCharacter(UChar32 c) const
    108     {
    109         unsigned index = indexForCharacter(c);
    110         if (const CustomFontData* customData = customFontToLoadAt(index))
    111             customData->beginLoadIfNeeded();
    112         return glyphDataForIndex(index);
    113     }
    114 
    115     ALWAYS_INLINE GlyphData glyphDataForIndex(unsigned index) const
    116     {
    117         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
    118         Glyph glyph = m_glyphs[index];
    119         if (hasPerGlyphFontData())
    120             return GlyphData(glyph, m_perGlyphFontData[index]);
    121         return GlyphData(glyph, glyph ? m_fontDataForAllGlyphs : 0);
    122     }
    123 
    124     ALWAYS_INLINE Glyph glyphForCharacter(UChar32 c) const
    125     {
    126         return glyphAt(indexForCharacter(c));
    127     }
    128 
    129     ALWAYS_INLINE Glyph glyphAt(unsigned index) const
    130     {
    131         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
    132         return m_glyphs[index];
    133     }
    134 
    135     void setGlyphDataForCharacter(UChar32 c, Glyph g, const SimpleFontData* f)
    136     {
    137         setGlyphDataForIndex(indexForCharacter(c), g, f);
    138     }
    139 
    140     void setGlyphDataForIndex(unsigned index, Glyph glyph, const SimpleFontData* fontData)
    141     {
    142         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
    143         m_glyphs[index] = glyph;
    144         setCustomFontToLoad(index, 0);
    145 
    146         if (hasPerGlyphFontData()) {
    147             m_perGlyphFontData[index] = fontData;
    148         } else {
    149             // A single-font GlyphPage already assigned m_fontDataForAllGlyphs in the constructor.
    150             ASSERT(!glyph || fontData == m_fontDataForAllGlyphs);
    151         }
    152     }
    153 
    154     void setGlyphDataForIndex(unsigned index, const GlyphData& glyphData)
    155     {
    156         setGlyphDataForIndex(index, glyphData.glyph, glyphData.fontData);
    157     }
    158 
    159     const CustomFontData* customFontToLoadAt(unsigned index) const
    160     {
    161         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
    162         return m_customFontToLoad ? m_customFontToLoad->at(index) : 0;
    163     }
    164 
    165     void setCustomFontToLoad(unsigned index, const CustomFontData* customFontToLoad)
    166     {
    167         if (!m_customFontToLoad) {
    168             if (!customFontToLoad)
    169                 return;
    170             m_customFontToLoad = CustomDataPage::create();
    171         }
    172         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
    173         m_customFontToLoad->set(index, customFontToLoad);
    174     }
    175 
    176     void removeFontDataFromSystemFallbackPage(const SimpleFontData* fontData)
    177     {
    178         // This method should only be called on the system fallback page, which is never single-font.
    179         ASSERT(hasPerGlyphFontData());
    180         for (size_t i = 0; i < size; ++i) {
    181             if (m_perGlyphFontData[i] == fontData) {
    182                 m_glyphs[i] = 0;
    183                 m_perGlyphFontData[i] = 0;
    184             }
    185         }
    186     }
    187 
    188     GlyphPageTreeNode* owner() const { return m_owner; }
    189 
    190 private:
    191     explicit GlyphPage(GlyphPageTreeNode* owner, const SimpleFontData* fontDataForAllGlyphs = 0)
    192         : m_fontDataForAllGlyphs(fontDataForAllGlyphs)
    193         , m_owner(owner)
    194     {
    195         memset(m_glyphs, 0, sizeof(m_glyphs));
    196         if (hasPerGlyphFontData())
    197             memset(m_perGlyphFontData, 0, sizeof(SimpleFontData*) * GlyphPage::size);
    198     }
    199 
    200     bool hasPerGlyphFontData() const { return !m_fontDataForAllGlyphs; }
    201 
    202     class CustomDataPage : public RefCounted<CustomDataPage> {
    203     public:
    204         static RefPtr<CustomDataPage> create() { return adoptRef(new CustomDataPage()); }
    205         const CustomFontData* at(size_t index) const { return m_customData[index]; }
    206         void set(size_t index, const CustomFontData* data) { m_customData[index] = data; }
    207     private:
    208         CustomDataPage() { memset(m_customData, 0, sizeof(m_customData)); }
    209         const CustomFontData* m_customData[size];
    210     };
    211 
    212     const SimpleFontData* m_fontDataForAllGlyphs;
    213     GlyphPageTreeNode* m_owner;
    214     RefPtr<CustomDataPage> m_customFontToLoad;
    215     Glyph m_glyphs[size];
    216 
    217     // NOTE: This array has (GlyphPage::size) elements if m_fontDataForAllGlyphs is null.
    218     const SimpleFontData* m_perGlyphFontData[0];
    219 };
    220 
    221 #if COMPILER(MSVC)
    222 #pragma warning(pop)
    223 #endif
    224 
    225 } // namespace blink
    226 
    227 #endif // GlyphPage_h
    228