IFontInstance.h

//========================================================================================
// 
// $File$
// 
// Owner: Eric Menninga
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
// 
// See the implementation CTPFontInstance.cpp and refer to the CoolType
// documentation for more information
// 
//========================================================================================

#ifndef __IFontInstance__
#define __IFontInstance__

#include "GRRefCountedObj.h"
#include "InterfacePtr.h"
#include "IFontMgr.h" // for IFontMgr::WritingDirection
#include "CTextEnum.h" // for Text::GlyphID, etc

class WideString;
class PMString;
class CTFontInst;
class PMMatrix;
class IOutlineInfo;
class PMRealGlyphPoint;

class IFontInstance : public grRefCountedObj
{
 public:
 virtual Text::GlyphID GetGlyphID(UTF32TextChar charCode) const = 0;

 virtual void GetGlyphIDs(const WideString& textString, K2Vector<Text::GlyphID>& glyphIDs) const = 0;

 virtual void AppendGlyphIDs(const UTF16TextChar* buffer, int32 bufSize, K2Vector<Text::GlyphID>& glyphIDs) const = 0;

 virtual int32 FillOutGlyphIDs(PMRealGlyphPoint *glyphPoints, int32 numGlyphs, const UTF16TextChar* textchars, int32 bufSize) const = 0;

 virtual Text::GlyphID GetNotDefinedGlyph() const = 0;

 virtual PMReal GetGlyphWidth(Text::GlyphID glyphID) const = 0;

 virtual void GetWidths(PMRealGlyphPoint *glyphPoints, int32 numGlyphs) const = 0;

 virtual PMRect GetGlyphBBox(Text::GlyphID glyphID) const = 0;

 virtual void MeasureWText(const UTF16TextChar* text, int32 utf16BufferLength, PMReal& xWidth, PMReal* yHeight = nil) const = 0;
 virtual void MeasureWText(const WideString& string, PMReal& xWidth, PMReal* yHeight = nil) const = 0;

 virtual void MeasureWText(const PMString& string, PMReal& xWidth, PMReal* yHeight = nil) const = 0;

 virtual bool16 HasKerningTable() const = 0;

 virtual void GetKerns(PMRealGlyphPoint *glyphPoints, int32 numGlyphs, bool16 vertical = kFalse, const char* scriptTag = nil, const char* langTag = nil) const = 0;

 enum { kNormalOutlines = 0,
 kHintedOutlines = 1,
 kVerticalOutlines = 2,
 kVerticalGlyphs = 4 } ;

 virtual void GetOutlineInfo(IOutlineInfo *callBack, Text::GlyphID glyphID, PMReal xOffset, PMReal yOffset, int32 flags = kNormalOutlines) const = 0;

 virtual PMReal GetAscent() const = 0;

 virtual PMReal GetDescent() const = 0;

 virtual PMReal GetCapHeight() const = 0;

 virtual PMReal GetXHeight() const = 0;

 virtual PMReal GetEmBoxHeight() const = 0;

 virtual void GetICFBoxInsets(PMReal * fromEmTop, PMReal * fromEmBottom) const = 0;

 virtual PMReal GetHorizEmBoxDepth() const = 0;

 virtual PMReal GetHorizICFBoxDepth() const = 0;

 virtual CTFontInst* GetCTFontInst() const = 0;

 virtual CTFontDict* GetParentCTFontDict() const = 0;

 virtual void GetDesignVector(PMReal* designVec, size_t& designVecLen) const = 0;

 virtual size_t GetNumDesignAxes() const = 0;

 virtual const PMMatrix& GetPMMatrix() const = 0;

 virtual IFontMgr::WritingDirection GetWritingDirection() const = 0;

 enum FeatureInfoFlags {
 kApplyGlyphSub = 1 << 0,
 kApplyGlyphPos = 1 << 1,
 kApplyGlyphSubAndPos = kApplyGlyphSub | kApplyGlyphPos,
// /** This flag is not used by ApplyFeatures. */
// kReportOriginalIndices = 1 << 2,
 kRightToLeft = 1<<3,
 kCTFlagsBitMask = 0x0F,

 kModifyWidthsInPlace = 1 << 5
 };

 enum {
 kNoChange = 0, //kCTOTNoChange
// kSingleSubstitute = 1<<0, // kCTOTSingleSubstitute
// kMultiSubstitute = 1<<1, // kCTOTMultiSubstitute
// kAlternate = 1<<3, // kCTOTAlternate
 kLigatureApplied = 1<<4, //kCTOTLigature
 kGlyphDeleted = 1<<5, //kCTOTDeleted
// kRepositioned = 1<<6 //kCTOTRepositioned
 };

 virtual bool16 ApplyFeatures(PMRealGlyphPoint* glyphPoints, size_t& numGlyphPoints, size_t &numGlyphPointsAvail,
 int32 numFeatures, const char* features, const int32* choiceIndices,
 const size_t *featureRanges, char* changeAttrib, FeatureInfoFlags flags,
 PMReal* penPos = nil, PMReal* caretPositions = nil,
 const char* scriptTag = nil, const char* langTag = nil) const = 0;


 virtual CTFontInstance* GetCTFontInstance() const = 0;

 virtual bool16 GermanLocaleDropsLigatures() const = 0;

};


template <>
class InterfacePtr<IFontInstance>
{
public:
 // Note: Constructing an InterfacePtr from an existing,
 // "real" interface pointer implies the InterfacePtr
 // now owns the reference that was held by the real pointer.
 InterfacePtr(IFontInstance * pFace)
 : fFace(pFace) {}

 ~InterfacePtr()
 { Release_(fFace); }

 InterfacePtr(void) : fFace(nil)
 {}

 InterfacePtr(const InterfacePtr<IFontInstance>& o) : fFace(AddRef_(o.get()))
 {}

 InterfacePtr<IFontInstance>& operator=(const InterfacePtr<IFontInstance>& p)
 { if (&p != this) reset(AddRef_(p.get())); return *this; }

 operator IFontInstance*() const
 { return fFace; }
 // We allow the cast operator to return a nil pointer
 // since it is valid to test against nil and may be valid
 // to pass a nil pointer to some methods.

 IFontInstance * operator ->() const
 {
 #ifdef DEBUG
 ASSERT_MSG(fFace != nil,"About to use nil interface ptr!");
 #endif
 return fFace;
 }

 // Added forget, get and reset from InterfacePtr
 IFontInstance* forget()
 {
 IFontInstance* result = fFace;
 fFace = 0;
 return result;
 }

 IFontInstance* get() const
 { return fFace; }

 void reset(IFontInstance* p = 0)
 {
 Release_(fFace);
 fFace = p;
 }

 void reset(const IFontInstance* p)
 {
 Release_(fFace);
 fFace = const_cast<IFontInstance*>(p);
 }

private:
 static IFontInstance* AddRef_(const IFontInstance* p)
 { if (p) p->AddRef(); return const_cast<IFontInstance*>(p);}
 static void Release_(IFontInstance* p)
 { if (p) p->Release(); }


 IFontInstance * fFace;
};
#endif