summaryrefslogtreecommitdiff
path: root/Build/source/libs/icu/icu-xetex/samples/layout/ScriptCompositeFontInstance.h
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/icu/icu-xetex/samples/layout/ScriptCompositeFontInstance.h')
-rw-r--r--Build/source/libs/icu/icu-xetex/samples/layout/ScriptCompositeFontInstance.h191
1 files changed, 191 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-xetex/samples/layout/ScriptCompositeFontInstance.h b/Build/source/libs/icu/icu-xetex/samples/layout/ScriptCompositeFontInstance.h
new file mode 100644
index 00000000000..241461769d0
--- /dev/null
+++ b/Build/source/libs/icu/icu-xetex/samples/layout/ScriptCompositeFontInstance.h
@@ -0,0 +1,191 @@
+/*
+ * %W% %E%
+ *
+ * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved
+ *
+ */
+
+#ifndef __SCRIPTCOMPOSITEFONTINSTANCE_H
+#define __SCRIPTCOMPOSITEFONTINSTANCE_H
+
+#include "layout/LETypes.h"
+#include "layout/LEFontInstance.h"
+
+#include "FontMap.h"
+
+// U_NAMESPACE_BEGIN
+
+class ScriptCompositeFontInstance : public LEFontInstance
+{
+public:
+
+ ScriptCompositeFontInstance(FontMap *fontMap);
+
+ virtual ~ScriptCompositeFontInstance();
+
+ /**
+ * Get a physical font which can render the given text. For composite fonts,
+ * if there is no single physical font which can render all of the text,
+ * return a physical font which can render an initial substring of the text,
+ * and set the <code>offset</code> parameter to the end of that substring.
+ *
+ * Internally, the LayoutEngine works with runs of text all in the same
+ * font and script, so it is best to call this method with text which is
+ * in a single script, passing the script code in as a hint. If you don't
+ * know the script of the text, you can use zero, which is the script code
+ * for characters used in more than one script.
+ *
+ * The default implementation of this method is intended for instances of
+ * <code>LEFontInstance</code> which represent a physical font. It returns
+ * <code>this</code> and indicates that the entire string can be rendered.
+ *
+ * This method will return a valid <code>LEFontInstance</code> unless you
+ * have passed illegal parameters, or an internal error has been encountered.
+ * For composite fonts, it may return the warning <code>LE_NO_SUBFONT_WARNING</code>
+ * to indicate that the returned font may not be able to render all of
+ * the text. Whenever a valid font is returned, the <code>offset</code> parameter
+ * will be advanced by at least one.
+ *
+ * Subclasses which implement composite fonts must override this method.
+ * Where it makes sense, they should use the script code as a hint to render
+ * characters from the COMMON script in the font which is used for the given
+ * script. For example, if the input text is a series of Arabic words separated
+ * by spaces, and the script code passed in is <code>arabScriptCode</code> you
+ * should return the font used for Arabic characters for all of the input text,
+ * including the spaces. If, on the other hand, the input text contains characters
+ * which cannot be rendered by the font used for Arabic characters, but which can
+ * be rendered by another font, you should return that font for those characters.
+ *
+ * @param chars - the array of Unicode characters.
+ * @param offset - a pointer to the starting offset in the text. On exit this
+ * will be set the the limit offset of the text which can be
+ * rendered using the returned font.
+ * @param limit - the limit offset for the input text.
+ * @param script - the script hint.
+ * @param success - set to an error code if the arguments are illegal, or no font
+ * can be returned for some reason. May also be set to
+ * <code>LE_NO_SUBFONT_WARNING</code> if the subfont which
+ * was returned cannot render all of the text.
+ *
+ * @return an <code>LEFontInstance</code> for the sub font which can render the characters, or
+ * <code>NULL</code> if there is an error.
+ *
+ * @see LEScripts.h
+ *
+ * @draft ICU 2.6
+ */
+ virtual const LEFontInstance *getSubFont(const LEUnicode chars[], le_int32 *offset, le_int32 limit, le_int32 script, LEErrorCode &success) const;
+
+ /**
+ * This method maps a single character to a glyph index, using the
+ * font's charcter to glyph map.
+ *
+ * @param ch - the character
+ *
+ * @return the glyph index
+ *
+ * @draft ICU 2.6
+ */
+ virtual LEGlyphID mapCharToGlyph(LEUnicode32 ch) const;
+
+ virtual const void *getFontTable(LETag tableTag) const;
+
+ virtual le_int32 getUnitsPerEM() const;
+
+ virtual le_int32 getAscent() const;
+
+ virtual le_int32 getDescent() const;
+
+ virtual le_int32 getLeading() const;
+
+ virtual void getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const;
+
+ virtual le_bool getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const;
+
+ float getXPixelsPerEm() const;
+
+ float getYPixelsPerEm() const;
+
+ float getScaleFactorX() const;
+
+ float getScaleFactorY() const;
+
+ /**
+ * ICU "poor man's RTTI", returns a UClassID for the actual class.
+ *
+ * @draft ICU 2.2
+ */
+ virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
+
+ /**
+ * ICU "poor man's RTTI", returns a UClassID for this class.
+ *
+ * @draft ICU 2.2
+ */
+ static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
+
+protected:
+ FontMap *fFontMap;
+
+private:
+
+ /**
+ * The address of this static class variable serves as this class's ID
+ * for ICU "poor man's RTTI".
+ */
+ static const char fgClassID;
+};
+
+inline const void *ScriptCompositeFontInstance::getFontTable(LETag /*tableTag*/) const
+{
+ return NULL;
+}
+
+// Can't get units per EM without knowing which sub-font, so
+// return a value that will make units == points
+inline le_int32 ScriptCompositeFontInstance::getUnitsPerEM() const
+{
+ return 1;
+}
+
+inline le_int32 ScriptCompositeFontInstance::getAscent() const
+{
+ return fFontMap->getAscent();
+}
+
+inline le_int32 ScriptCompositeFontInstance::getDescent() const
+{
+ return fFontMap->getDescent();
+}
+
+inline le_int32 ScriptCompositeFontInstance::getLeading() const
+{
+ return fFontMap->getLeading();
+}
+
+inline float ScriptCompositeFontInstance::getXPixelsPerEm() const
+{
+ return fFontMap->getPointSize();
+}
+
+inline float ScriptCompositeFontInstance::getYPixelsPerEm() const
+{
+ return fFontMap->getPointSize();
+}
+
+// Can't get a scale factor without knowing the sub-font, so
+// return 1.0.
+inline float ScriptCompositeFontInstance::getScaleFactorX() const
+{
+ return 1.0;
+}
+
+// Can't get a scale factor without knowing the sub-font, so
+// return 1.0
+inline float ScriptCompositeFontInstance::getScaleFactorY() const
+{
+ return 1.0;
+}
+
+// U_NAMESPACE_END
+#endif