1 /* 2 * %W% %E% 3 * 4 * (C) Copyright IBM Corp. 1998-2005 - 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 * @draft ICU 2.6 76 */ 77 virtual const LEFontInstance *getSubFont(const LEUnicode chars[], le_int32 *offset, le_int32 limit, le_int32 script, LEErrorCode &success) const; 78 79 /** 80 * This method maps a single character to a glyph index, using the 81 * font's charcter to glyph map. 82 * 83 * @param ch - the character 84 * 85 * @return the glyph index 86 * 87 * @draft ICU 2.6 88 */ 89 virtual LEGlyphID mapCharToGlyph(LEUnicode32 ch) const; 90 91 virtual const void *getFontTable(LETag tableTag) const; 92 93 virtual le_int32 getUnitsPerEM() const; 94 95 virtual le_int32 getAscent() const; 96 97 virtual le_int32 getDescent() const; 98 99 virtual le_int32 getLeading() const; 100 101 virtual void getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const; 102 103 virtual le_bool getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const; 104 105 float getXPixelsPerEm() const; 106 107 float getYPixelsPerEm() const; 108 109 float getScaleFactorX() const; 110 111 float getScaleFactorY() const; 112 113 /** 114 * ICU "poor man's RTTI", returns a UClassID for the actual class. 115 * 116 * @draft ICU 2.2 117 */ 118 virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } 119 120 /** 121 * ICU "poor man's RTTI", returns a UClassID for this class. 122 * 123 * @draft ICU 2.2 124 */ 125 static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } 126 127 protected: 128 FontMap *fFontMap; 129 130 private: 131 132 /** 133 * The address of this static class variable serves as this class's ID 134 * for ICU "poor man's RTTI". 135 */ 136 static const char fgClassID; 137 }; 138 139 inline const void *ScriptCompositeFontInstance::getFontTable(LETag /*tableTag*/) const 140 { 141 return NULL; 142 } 143 144 // Can't get units per EM without knowing which sub-font, so 145 // return a value that will make units == points 146 inline le_int32 ScriptCompositeFontInstance::getUnitsPerEM() const 147 { 148 return 1; 149 } 150 151 inline le_int32 ScriptCompositeFontInstance::getAscent() const 152 { 153 return fFontMap->getAscent(); 154 } 155 156 inline le_int32 ScriptCompositeFontInstance::getDescent() const 157 { 158 return fFontMap->getDescent(); 159 } 160 161 inline le_int32 ScriptCompositeFontInstance::getLeading() const 162 { 163 return fFontMap->getLeading(); 164 } 165 166 inline float ScriptCompositeFontInstance::getXPixelsPerEm() const 167 { 168 return fFontMap->getPointSize(); 169 } 170 171 inline float ScriptCompositeFontInstance::getYPixelsPerEm() const 172 { 173 return fFontMap->getPointSize(); 174 } 175 176 // Can't get a scale factor without knowing the sub-font, so 177 // return 1.0. 178 inline float ScriptCompositeFontInstance::getScaleFactorX() const 179 { 180 return 1.0; 181 } 182 183 // Can't get a scale factor without knowing the sub-font, so 184 // return 1.0 185 inline float ScriptCompositeFontInstance::getScaleFactorY() const 186 { 187 return 1.0; 188 } 189 190 // U_NAMESPACE_END 191 #endif 192