1/* 2 * %W% %E% 3 * 4 * Copyright (C) 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 21class ScriptCompositeFontInstance : public LEFontInstance 22{ 23public: 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 122protected: 123 FontMap *fFontMap; 124 125private: 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 134inline 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 141inline le_int32 ScriptCompositeFontInstance::getUnitsPerEM() const 142{ 143 return 1; 144} 145 146inline le_int32 ScriptCompositeFontInstance::getAscent() const 147{ 148 return fFontMap->getAscent(); 149} 150 151inline le_int32 ScriptCompositeFontInstance::getDescent() const 152{ 153 return fFontMap->getDescent(); 154} 155 156inline le_int32 ScriptCompositeFontInstance::getLeading() const 157{ 158 return fFontMap->getLeading(); 159} 160 161inline float ScriptCompositeFontInstance::getXPixelsPerEm() const 162{ 163 return fFontMap->getPointSize(); 164} 165 166inline 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. 173inline 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 180inline float ScriptCompositeFontInstance::getScaleFactorY() const 181{ 182 return 1.0; 183} 184 185// U_NAMESPACE_END 186#endif 187