OdFont.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
 
 
// OdFont.h: interface for the OdFont class.
//
 
#if !defined(AFX_ODFONT_H__0B76813A_DCFA_450E_8591_B6C6F1ED76EC__INCLUDED_)
#define AFX_ODFONT_H__0B76813A_DCFA_450E_8591_B6C6F1ED76EC__INCLUDED_
 
#include "RxObject.h"
#include "OdArray.h"
#include "OdCharMapper.h"
 
// For memset below
#include <memory.h>
 
class OdGiCommonDraw;
class OdGiConveyorGeometry;
class OdGePoint2d;
class OdGePoint3d;
class OdStreamBuf;
 
#include "TD_PackPush.h"
 
typedef enum {
  kFontTypeUnknown    = 0,
  kFontTypeShx        = 1,
  kFontTypeTrueType   = 2,
  kFontTypeShape      = 3, 
  kFontTypeBig        = 4,
  kFontTypeRsc        = 5 
} OdFontType;
 
struct FIRSTDLL_EXPORT OdCharacterProperties
{
  OdCharacterProperties()
  { ::memset(this, 0, sizeof(*this)); }
  bool  bUnderlined;
  bool  bOverlined;
  bool  bStriked;
  bool  bLastChar;
  bool  bInBigFont;
  bool  bAsian;
  bool  bValid;
  OdChar uCode;
};
 
struct FIRSTDLL_EXPORT OdTextProperties
{
  double   m_trackingPercent;
  OdUInt16 m_flags;
  OdUInt16 m_textQuality;
  enum
  {
    kNormalText   = 0x01,
    kVerticalText = 0x02,
    kUnderlined   = 0x04,
    kOverlined    = 0x08,
    kLastChar     = 0x10,
    kInBigFont    = 0x20,
    kInclPenups   = 0x40,
    kZeroNormals  = 0x80,
    kBezierCurves = 0x100,
    kStriked      = 0x200,
    kLastPosOnly  = 0x400,    // 
    kTriangleCache = 0x800,
    kIsGlyph      = 0x1000
   ,kExtentsCalculation = 0x4000 //FELIX_CHANGE
  };
  OdChar  m_prevChar;
public:
  OdTextProperties() : m_flags(0), m_trackingPercent(0.0), m_textQuality(50), m_prevChar(0) {}
 
  bool isNormalText() const { return GETBIT(m_flags, kNormalText); }
 
  void setNormalText(bool value) { SETBIT(m_flags, kNormalText, value); }
 
  bool isVerticalText() const { return GETBIT(m_flags, kVerticalText); }
 
  void setVerticalText(bool value) { SETBIT(m_flags, kVerticalText, value); }
 
  bool isUnderlined() const { return GETBIT(m_flags, kUnderlined); }
 
  void setUnderlined(bool value) { SETBIT(m_flags, kUnderlined, value); }
 
  bool isOverlined() const { return GETBIT(m_flags, kOverlined); }
 
  void setOverlined(bool value) { SETBIT(m_flags, kOverlined, value); }
 
  bool isStriked() const { return GETBIT(m_flags, kStriked); }
 
  void setStriked(bool value) { SETBIT(m_flags, kStriked, value); }
 
  bool isLastChar() const { return GETBIT(m_flags, kLastChar); }
 
  void setLastChar(bool value) { SETBIT(m_flags, kLastChar, value); }
 
  bool isInBigFont() const { return GETBIT(m_flags, kInBigFont); }
 
  void setInBigFont(bool value) { SETBIT(m_flags, kInBigFont, value); }
 
  bool isIncludePenups() const { return GETBIT(m_flags, kInclPenups); }
 
  void setIncludePenups(bool value) { SETBIT(m_flags, kInclPenups, value); }
 
  bool isZeroNormals() const { return GETBIT(m_flags, kZeroNormals); }
 
  void setZeroNormals(bool value) { SETBIT(m_flags, kZeroNormals, value); }
 
  bool ttfPolyDraw() const { return GETBIT(m_flags, kBezierCurves); }
 
  void setTtfPolyDraw(bool bFlag) { SETBIT(m_flags, kBezierCurves, bFlag); }
 
  double trackingPercent() const {return m_trackingPercent; }
 
  void setTrackingPercent(double trackingPercent) { m_trackingPercent = trackingPercent; }
 
  OdUInt32 textQuality() const { return m_textQuality; }
 
  void setTextQuality(OdUInt32 val) { m_textQuality = (OdUInt16)val; }
 
  bool isTriangleCache() const { return GETBIT(m_flags, kTriangleCache); }
 
  void setSetTriangleCache(bool value) { SETBIT(m_flags, kTriangleCache, value); }
 
  // For internal use only
  bool isLastPosOnly() const { return GETBIT(m_flags, kLastPosOnly); }
 
  void setLastPosOnly(bool value) { SETBIT(m_flags, kLastPosOnly, value); }
 
  bool isGlyph() const { return GETBIT(m_flags, kIsGlyph); }
 
  void setGlyph(bool value) { SETBIT(m_flags, kIsGlyph, value); }
};
 
typedef OdUInt32 OdFontSubType;
 
class OdGePoint2d;
class OdGiConveyorGeometry;
class OdTtfDescriptor;
 
class FIRSTDLL_EXPORT OdFont : public OdRxObject
{
  OdUInt32 m_Flags;
 
public:
  ODRX_DECLARE_MEMBERS(OdFont);
 
  OdFont() : m_Flags(0) {}
 
  enum
  {
    kBigFont10 = 0x0001,
    kUniFont10 = 0x0002,
    kFont10    = 0x0004,
    kFont11    = 0x0008,
    kFont10A   = 0x0010,
    kTrueType  = 0x0020,
    kFontGdt   = 0x0040,
    kFontSimplex6 = 0x0080,
    kShapes11   = 0x0100,
    kFontRsc    = 0x0200   // MicroStation resource file.
  };
 
    OdUInt32 getFlags() const { return m_Flags; }
 
    OdUInt32 flags() { return m_Flags; }
 
    void setFlags(OdUInt32 fontFlags) { m_Flags = fontFlags; }
 
    void addFlag(OdUInt32 fontFlags) { m_Flags |= fontFlags; }
 
      virtual OdResult initialize(OdStreamBuf* pStreamBuf) = 0;
 
  virtual OdResult     drawCharacter(OdChar character, OdGePoint2d& advance, OdGiCommonDraw* pWd,
                                     OdTextProperties& textProperties) = 0;
 
  virtual OdResult     drawCharacter(OdChar character, OdGePoint2d& advance,
                                     OdGiConveyorGeometry* pGeometry,
                                     OdTextProperties& textProperties) = 0;
  virtual double       getAbove() const = 0;
 
  virtual double       getBelow() const = 0;
 
  virtual OdUInt32     getAvailableChars(OdCharArray& characters) = 0;
 
  virtual bool        hasCharacter(OdChar character) = 0;
  
  virtual double      getHeight() const                                                   // MKU 20.02.2003
  {
    return getAbove() + getBelow();
  }
 
  virtual double getInternalLeading() const
  {
    return 0;
  }
 
 
  //  removed here from GiContextForDbDatabase.cpp              // MKU 04.03.2003
 
  double fontAbove() const  
  {
    double above = getAbove();
    if(OdZero(above))
    {
      above = 1.0;
    }
    return above;
  }
 
  virtual double getUnderlinePos(double textSize) const
  {
    return -0.2 * textSize;
    
  }
  virtual double getOverlinePos(double textSize) const
  {
    return 1.2 * textSize;
  }
  
  virtual bool isShxFont()
  {
    return true;
  }
 
  virtual double getAverageWidth()
  {
    return 0.0;
  }
 
  virtual void getScore( OdChar character,
                         OdGePoint2d& advance, 
                         OdGePoint3d* pointsOver,
                         OdGePoint3d* pointsUnder,
                         const OdTextProperties& textFlags);
 
  virtual OdUInt32 getFontData(
    OdUInt32 dwTable,     // Metric table to query
    OdUInt32 dwOffset,    // Offset into table being queried
    void * pBuffer,  // Pointer to buffer for returned data
    OdUInt32 cbData       ) const;
 
  virtual bool supportsVerticalMode()
  {
    return false;
  }
 
  virtual OdString getFileName() const
  {
    return OdString();
  }
 
  virtual void getDescriptor(OdTtfDescriptor& descr) const
  {
  }
 
  virtual OdInt32 getLogFont(void* lpLogFont) const
  {
    return -1;
  }
};
 
inline void OdFont::getScore( OdChar /*character*/, 
                         OdGePoint2d& /*advance*/, 
                         OdGePoint3d* /*pointsOver*/,
                         OdGePoint3d* /*pointsUnder*/,
                         const OdTextProperties& /*flags*/ )
  {}
 
inline OdUInt32 OdFont::getFontData(
    OdUInt32 /*dwTable*/,     // Metric table to query
    OdUInt32 /*dwOffset*/,    // Offset into table being queried
    void * /*lpvBuffer*/,  // Pointer to buffer for returned data
    OdUInt32 /*cbData*/       ) const
  {
    return OdUInt32(-1);
  }
 
 
typedef OdSmartPtr<OdFont> OdFontPtr;
 
class FIRSTDLL_EXPORT OdBaseTextIterator : public OdRxObject
{
public:
  virtual OdChar nextChar() = 0;
  virtual const OdCharacterProperties& currProperties() const = 0;
 
  virtual const OdChar* currPos() const = 0;
};
 
typedef OdSmartPtr<OdBaseTextIterator> OdBaseTextIteratorPtr;
 
#include "TD_PackPop.h"
 
#endif // !defined(AFX_ODFONT_H__0B76813A_DCFA_450E_8591_B6C6F1ED76EC__INCLUDED_)