fs_ofdtextobject.h

#ifndef FS_OFD_TEXTOBJECT_H_
#define FS_OFD_TEXTOBJECT_H_

#include "common/fs_common.h"
#include "fs_ofdgraphicsobject.h"

namespace foxit {
namespace ofd {
class TextPieceInfo;
namespace graphics {
class TextLayout;

class CharInfo FS_FINAL : public Object {
 public:
  CharInfo() :
    charcode(0),
    x(0.0f),
    y(0.0f) {
  }
  CharInfo(foxit::uint32 charcode, float x, float y) :
    charcode(charcode),
    x(x),
    y(y){
  }

  CharInfo& operator=(const CharInfo& other) {
    charcode = other.charcode;
    x = other.x;
    y = other.y;

    return *this;
  }

  void Set(foxit::uint32 charcode, float x, float y) {
    this->charcode = charcode;
    this->x = x;
    this->y = y;
  }

  foxit::uint32 charcode;

  float x;

  float y;
};

FSDK_DEFINE_ARRAY(CharInfoArray, CharInfo)


class OFDTextObject FS_FINAL : public OFDGraphicsObject {
 public:
  typedef enum _ReadDirectionType {
    e_ReadDirectionLeftToRight = 0,
    e_ReadDirectionTopToBottom = 1,
    e_ReadDirectionRightToLeft = 2,
    e_ReadDirectionBottomToTop = 3
  } ReadDirectionType;
  
  typedef enum _CharDirectionType {
    e_CharDirectionNormal = 0,
    e_CharDirectionRight = 1,
    e_CharDirectionBottom = 2,
    e_CharDirectionLeft = 3
  } CharDirectionType;
  

  explicit OFDTextObject(OFDGraphicsObject object);

  ~OFDTextObject();

  OFDTextObject(const OFDTextObject& other);

  OFDTextObject& operator = (const OFDTextObject& other);

  bool operator == (const OFDTextObject& other) const;

  bool operator != (const OFDTextObject& other) const;

  bool IsEmpty() const;

  WString GetFontName();

  float GetFontSize();

  bool IsFill();

  bool IsStroke();

  float GetHScale();

  ReadDirectionType GetReadDirection();

  CharDirectionType GetCharDirection();

  int GetWeight();

  bool IsItalic();

  CharInfoArray GetCharInfo();

  void InsertText(const String& text, float x_pos, float y_pos, bool calculate_width = true);

  void ModifyText(const String& text);

  void AddUnderline();

  void SetFontName(const WString& font_name);

  void SetFontSize(float font_size);

  void SetHScale(float scale);

  void SetReadDirection(ReadDirectionType type);

  void SetCharDirection(CharDirectionType type);

  void SetWeight(int weight);

  void SetItalic(bool italic);

  void SetCharInfos(const foxit::UInt32Array& char_infos, float x, float y);

  void SetTextPieceInfos(const foxit::ofd::TextPieceInfo& text_piece_info);

  TextLayout GetTextLayout();

  explicit OFDTextObject(FS_HANDLE handle);
};

class TextLayout FS_FINAL : public Base {
 public:
  typedef enum _LayoutHAlignment {
    e_LayoutHLeft = 0,
    e_LayoutHCenter = 1,
    e_LayoutHRight = 2
  } LayoutHAlignment;
  
  typedef enum _LayoutVAlignment {
    e_LayoutVTop = 0,
    e_LayoutVCenter = 1,
    e_LayoutVBottom = 2
  } LayoutVAlignment;
  

  ~TextLayout();

  TextLayout(const TextLayout& other);

  TextLayout& operator = (const TextLayout& other);

  bool operator == (const TextLayout& other) const;

  bool operator != (const TextLayout& other) const;

  bool IsEmpty() const;

  float GetTextEndOffsetX();

  float GetTextEndOffsetY();

  void SetText(const WString& text);

  void SetRotation(foxit::common::Rotation rotation);

  void SetFontName(const WString& font_name);

  void SetSubFontName(const WString& font_name);

  void SetWeight(int weight);

  void EnableItalic(bool italic);

  void AddUnderline();

  void SetRTFFontSize(float font_size);

  void EnableJustifyX(bool set);

  void EnableJustifyY(bool set);

  void SetLineCharNumer(int num);

  void SetLineBitNumber(int num);

  void SetLineSpace(float space);

  void SetLineBreak(const String& line_break);

  void EnableAutoSize(bool auto_size);

  void EnableVertical(bool vertical);

  void SetFontSize(float font_size);

  void SetHAlignment(LayoutHAlignment align);

  void SetVAlignment(LayoutVAlignment align);

  void EnableMultiline(bool set);

  void Update();

  explicit TextLayout(FS_HANDLE handle);
};

}  // namespace graphics
}  // namespace ofd
}  // namespace foxit

#endif  // FS_OFD_TEXTOBJECT_H_