icuSources/samples/layout/ScriptCompositeFontInstance.h

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