Home | History | Annotate | Download | only in layout 
      1 /*
      2  * %W% %E%
      3  *
      4  *  2016 and later: Unicode, Inc. and others.
      5  * License & terms of use: http://www.unicode.org/copyright.html#License
      6  *
      7  * (C) Copyright IBM Corp. 1998-2011 - All Rights Reserved
      8  *
      9  */
     10 
     11 #ifndef __SCRIPTCOMPOSITEFONTINSTANCE_H
     12 #define __SCRIPTCOMPOSITEFONTINSTANCE_H
     13 
     14 #include "layout/LETypes.h"
     15 #include "layout/LEFontInstance.h"
     16 
     17 #include "FontMap.h"
     18 
     19 // U_NAMESPACE_BEGIN
     20 
     21 class ScriptCompositeFontInstance : public LEFontInstance
     22 {
     23 public:
     24 
     25     ScriptCompositeFontInstance(FontMap *fontMap);
     26 
     27     virtual ~ScriptCompositeFontInstance();
     28 
     29       /**
     30      * Get a physical font which can render the given text. For composite fonts,
     31      * if there is no single physical font which can render all of the text,
     32      * return a physical font which can render an initial substring of the text,
     33      * and set the <code>offset</code> parameter to the end of that substring.
     34      *
     35      * Internally, the LayoutEngine works with runs of text all in the same
     36      * font and script, so it is best to call this method with text which is
     37      * in a single script, passing the script code in as a hint. If you don't
     38      * know the script of the text, you can use zero, which is the script code
     39      * for characters used in more than one script.
     40      *
     41      * The default implementation of this method is intended for instances of
     42      * <code>LEFontInstance</code> which represent a physical font. It returns
     43      * <code>this</code> and indicates that the entire string can be rendered.
     44      *
     45      * This method will return a valid <code>LEFontInstance</code> unless you
     46      * have passed illegal parameters, or an internal error has been encountered.
     47      * For composite fonts, it may return the warning <code>LE_NO_SUBFONT_WARNING</code>
     48      * to indicate that the returned font may not be able to render all of
     49      * the text. Whenever a valid font is returned, the <code>offset</code> parameter
     50      * will be advanced by at least one.
     51      *
     52      * Subclasses which implement composite fonts must override this method.
     53      * Where it makes sense, they should use the script code as a hint to render
     54      * characters from the COMMON script in the font which is used for the given
     55      * script. For example, if the input text is a series of Arabic words separated
     56      * by spaces, and the script code passed in is <code>arabScriptCode</code> you
     57      * should return the font used for Arabic characters for all of the input text,
     58      * including the spaces. If, on the other hand, the input text contains characters
     59      * which cannot be rendered by the font used for Arabic characters, but which can
     60      * be rendered by another font, you should return that font for those characters.
     61      *
     62      * @param chars   - the array of Unicode characters.
     63      * @param offset  - a pointer to the starting offset in the text. On exit this
     64      *                  will be set the the limit offset of the text which can be
     65      *                  rendered using the returned font.
     66      * @param limit   - the limit offset for the input text.
     67      * @param script  - the script hint.
     68      * @param success - set to an error code if the arguments are illegal, or no font
     69      *                  can be returned for some reason. May also be set to
     70      *                  <code>LE_NO_SUBFONT_WARNING</code> if the subfont which
     71      *                  was returned cannot render all of the text.
     72      *
     73      * @return an <code>LEFontInstance</code> for the sub font which can render the characters, or
     74      *         <code>NULL</code> if there is an error.
     75      *
     76      * @see LEScripts.h
     77      */
     78     virtual const LEFontInstance *getSubFont(const LEUnicode chars[], le_int32 *offset, le_int32 limit, le_int32 script, LEErrorCode &success) const;
     79 
     80     /**
     81      * This method maps a single character to a glyph index, using the
     82      * font's charcter to glyph map.
     83      *
     84      * @param ch - the character
     85      *
     86      * @return the glyph index
     87      */
     88     virtual LEGlyphID mapCharToGlyph(LEUnicode32 ch) const;
     89 
     90     virtual const void *getFontTable(LETag tableTag) const;
     91 
     92     virtual le_int32 getUnitsPerEM() const;
     93 
     94     virtual le_int32 getAscent() const;
     95 
     96     virtual le_int32 getDescent() const;
     97 
     98     virtual le_int32 getLeading() const;
     99 
    100     virtual void getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const;
    101 
    102     virtual le_bool getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const;
    103 
    104     float getXPixelsPerEm() const;
    105 
    106     float getYPixelsPerEm() const;
    107 
    108     float getScaleFactorX() const;
    109 
    110     float getScaleFactorY() const;
    111 
    112     /**
    113      * ICU "poor man's RTTI", returns a UClassID for the actual class.
    114      */
    115     virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
    116 
    117     /**
    118      * ICU "poor man's RTTI", returns a UClassID for this class.
    119      */
    120     static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
    121 
    122 protected:
    123     FontMap *fFontMap;
    124 
    125 private:
    126 
    127     /**
    128      * The address of this static class variable serves as this class's ID
    129      * for ICU "poor man's RTTI".
    130      */
    131     static const char fgClassID;
    132 };
    133 
    134 inline const void *ScriptCompositeFontInstance::getFontTable(LETag /*tableTag*/) const
    135 {
    136     return NULL;
    137 }
    138 
    139 // Can't get units per EM without knowing which sub-font, so
    140 // return a value that will make units == points
    141 inline le_int32 ScriptCompositeFontInstance::getUnitsPerEM() const
    142 {
    143     return 1;
    144 }
    145 
    146 inline le_int32 ScriptCompositeFontInstance::getAscent() const
    147 {
    148     return fFontMap->getAscent();
    149 }
    150 
    151 inline le_int32 ScriptCompositeFontInstance::getDescent() const
    152 {
    153     return fFontMap->getDescent();
    154 }
    155 
    156 inline le_int32 ScriptCompositeFontInstance::getLeading() const
    157 {
    158     return fFontMap->getLeading();
    159 }
    160 
    161 inline float ScriptCompositeFontInstance::getXPixelsPerEm() const
    162 {
    163     return fFontMap->getPointSize();
    164 }
    165 
    166 inline float ScriptCompositeFontInstance::getYPixelsPerEm() const
    167 {
    168     return fFontMap->getPointSize();
    169 }
    170 
    171 // Can't get a scale factor without knowing the sub-font, so
    172 // return 1.0.
    173 inline float ScriptCompositeFontInstance::getScaleFactorX() const
    174 {
    175     return 1.0;
    176 }
    177 
    178 // Can't get a scale factor without knowing the sub-font, so
    179 // return 1.0
    180 inline float ScriptCompositeFontInstance::getScaleFactorY() const
    181 {
    182     return 1.0;
    183 }
    184 
    185 // U_NAMESPACE_END
    186 #endif
    187