//#include "tw/mainshell.h"

#include "tools/tool.h"

#include "tools/toolutils.h"

#include "tools/toolhandle.h"

#include "tstroke.h"

#include "tmathutil.h"

#include "tproperty.h"

#include "tenv.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tframehandle.h"

#include "tvectorimage.h"

#include "ttoonzimage.h"

#include "toonz/toonzimageutils.h"

#include "tools/cursors.h"

#include "tundo.h"

#include "tvectorgl.h"

#include "tgl.h"

#include "tregion.h"

#include "tvectorrenderdata.h"

#include "toonz/tpalettehandle.h"

#include "toonzqt/selection.h"

#include "toonzqt/imageutils.h"

#include "trop.h"

#include "toonz/ttileset.h"

#include "toonz/glrasterpainter.h"

#include "toonz/stage.h"

#include "tfont.h"

// For Qt translation support

#include <qcoreapplication></qcoreapplication>

#include <qclipboard></qclipboard>

#include <qapplication></qapplication>

#include <qmimedata></qmimedata>

//#include "tw/message.h"

//#include "tw/ime.h"

using namespace ToolUtils;

namespace {

//---------------------------------------------------------

//

// helper functions

//

//---------------------------------------------------------

void paintRegion(TRegion *region, int styleId, bool paint) {

  UINT j, regNum = region->getSubregionCount();

  if (paint) region->setStyle(styleId);

  for (j = 0; j < regNum; j++)

    paintRegion(region->getSubregion(j), styleId, !paint);

}

//---------------------------------------------------------

void paintChar(const TVectorImageP &image, int styleId) {

  // image->setPalette( getApplication()->getCurrentScene()->getPalette());

  // image->setPalette(getCurrentPalette());

  UINT j;

  UINT strokeNum = image->getStrokeCount();

  for (j = 0; j < strokeNum; j++) image->getStroke(j)->setStyle(styleId);

  image->enableRegionComputing(true, true);

  image->findRegions();

  UINT regNum = image->getRegionCount();

  for (j = 0; j < regNum; j++) paintRegion(image->getRegion(j), styleId, true);

}

//---------------------------------------------------------

// Type, vars, ecc.

//

//---------------------------------------------------------

TEnv::StringVar EnvCurrentFont("CurrentFont", "MS UI Gothic");

//! numero di pixel attorno al testo

const double cBorderSize = 15;

//---------------------------------------------------------

//

// UNDO

//

//---------------------------------------------------------

class UndoTypeTool final : public ToolUtils::TToolUndo {

  std::vector<tstroke *=""> m_strokes;</tstroke>

  std::vector<tfilledregioninf> *m_fillInformationBefore,</tfilledregioninf>

      *m_fillInformationAfter;

  TVectorImageP m_image;

public:

  UndoTypeTool(std::vector<tfilledregioninf> *fillInformationBefore,</tfilledregioninf>

               std::vector<tfilledregioninf> *fillInformationAfter,</tfilledregioninf>

               TXshSimpleLevel *level, const TFrameId &frameId,

               bool isFrameCreated, bool isLevelCreated)

      : ToolUtils::TToolUndo(level, frameId, isFrameCreated, isLevelCreated)

      , m_fillInformationBefore(fillInformationBefore)

      , m_fillInformationAfter(fillInformationAfter) {}

  ~UndoTypeTool() {

    delete m_fillInformationBefore;

    delete m_fillInformationAfter;

    clearPointerContainer(m_strokes);

  }

  void addStroke(TStroke *stroke) {

    TStroke *s = new TStroke(*stroke);

    s->setId(stroke->getId());

    m_strokes.push_back(s);

  }

  void undo() const override {

    TTool::Application *application = TTool::getApplication();

    TVectorImageP image = m_level->getFrame(m_frameId, true);

    assert(!!image);

    if (!image) return;

    QMutexLocker lock(image->getMutex());

    UINT i;

    for (i = 0; i < m_strokes.size(); i++) {

      VIStroke *stroke = image->getStrokeById(m_strokes[i]->getId());

      if (!stroke) return;

      image->deleteStroke(stroke);

    }

    if (m_fillInformationBefore) {

      UINT size = m_fillInformationBefore->size();

      TRegion *reg;

      for (i = 0; i < size; i++) {

        reg = image->getRegion((*m_fillInformationBefore)[i].m_regionId);

        assert(reg);

        if (reg) reg->setStyle((*m_fillInformationBefore)[i].m_styleId);

      }

    }

    removeLevelAndFrameIfNeeded();

    application->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

  void redo() const override {

    insertLevelAndFrameIfNeeded();

    TVectorImageP image = m_level->getFrame(m_frameId, true);

    assert(!!image);

    if (!image) return;

    TTool::Application *application = TTool::getApplication();

    QMutexLocker lock(image->getMutex());

    UINT i;

    for (i = 0; i < m_strokes.size(); i++) {

      TStroke *stroke = new TStroke(*m_strokes[i]);

      stroke->setId(m_strokes[i]->getId());

      image->addStroke(stroke);

    }

    if (image->isComputedRegionAlmostOnce()) image->findRegions();

    if (m_fillInformationAfter) {

      UINT size = m_fillInformationAfter->size();

      TRegion *reg;

      for (i = 0; i < size; i++) {

        reg = image->getRegion((*m_fillInformationAfter)[i].m_regionId);

        assert(reg);

        if (reg) reg->setStyle((*m_fillInformationAfter)[i].m_styleId);

      }

    }

    application->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

  int getSize() const override {

    if (m_fillInformationAfter && m_fillInformationBefore)

      return sizeof(*this) +

             m_fillInformationBefore->capacity() * sizeof(TFilledRegionInf) +

             m_fillInformationAfter->capacity() * sizeof(TFilledRegionInf) +

             +m_strokes.capacity() * sizeof(TStroke) + 500;

    else

      return sizeof(*this) + m_strokes.capacity() * sizeof(TStroke) + 500;

  }

  QString getToolName() override { return QString("Type Tool"); }

};

//---------------------------------------------------------

class RasterUndoTypeTool final : public TRasterUndo {

  TTileSetCM32 *m_afterTiles;

public:

  RasterUndoTypeTool(TTileSetCM32 *beforeTiles, TTileSetCM32 *afterTiles,

                     TXshSimpleLevel *level, const TFrameId &id,

                     bool createdFrame, bool createdLevel)

      : TRasterUndo(beforeTiles, level, id, createdFrame, createdLevel, 0)

      , m_afterTiles(afterTiles) {}

  ~RasterUndoTypeTool() { delete m_afterTiles; }

  void redo() const override {

    insertLevelAndFrameIfNeeded();

    TToonzImageP image = getImage();

    if (!image) return;

    if (m_afterTiles) {

      ToonzImageUtils::paste(image, m_afterTiles);

      ToolUtils::updateSaveBox();

    }

    TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

  int getSize() const override {

    if (m_afterTiles)

      return TRasterUndo::getSize() + m_afterTiles->getMemorySize();

    else

      return TRasterUndo::getSize();

  }

  QString getToolName() override { return QString("Type Tool"); }

};

//---------------------------------------------------------

//

// StrokeChar

//

// E' la TVectorImage che corrisponde ad un carattere

// (piu' le varie info che permettono di ricrearlo)

//

//---------------------------------------------------------

class StrokeChar {

public:

  // TVectorImageP m_char;

  TImageP m_char;

  double m_offset;

  TPointD m_charPosition;

  int m_key;

  int m_styleId;

  StrokeChar(TImageP _char, double offset, int key, int styleId)

      : m_char(_char)

      , m_offset(offset)

      , m_charPosition(TPointD(0, 0))

      , m_key(key)

      , m_styleId(styleId) {}

  bool isReturn() const { return m_key == (int)(QChar('\r').unicode()); }

  void update(TAffine scale, int nextCode = 0) {

    if (!isReturn()) {

      if (TVectorImageP vi = m_char) {

        vi = m_char = new TVectorImage;

        TPoint adv  = TFontManager::instance()->drawChar(vi, m_key, nextCode);

        vi->transform(scale);

        paintChar(vi, m_styleId);

        m_offset = (scale * TPointD((double)(adv.x), (double)(adv.y))).x;

      } else {

        TRasterCM32P newRasterCM;

        TPoint p;

        TPoint adv = TFontManager::instance()->drawChar(

            (TRasterCM32P &)newRasterCM, p, m_styleId, (wchar_t)m_key,

            (wchar_t)nextCode);

        // m_char->transform(scale);

        m_offset = (scale * TPointD((double)(adv.x), (double)(adv.y))).x;

        m_char = new TToonzImage(newRasterCM, newRasterCM->getBounds());

      }

    }

  }

};

}  //  namespace

//---------------------------------------------------------

//

// TypeTool

//

//---------------------------------------------------------

class TypeTool final : public TTool {

  Q_DECLARE_TR_FUNCTIONS(TypeTool)

  // Properties

  TEnumProperty m_fontFamilyMenu;

  TEnumProperty m_typeFaceMenu;

  TBoolProperty m_vertical;

  TEnumProperty m_size;

  TPropertyGroup m_prop[2];

  // valori correnti di alcune Properties,

  // duplicati per permettere controlli sulla validita' o per ottimizzazione

  std::wstring m_fontFamily;

  std::wstring m_typeface;

  double m_dimension;

  bool m_validFonts;  // false iff there are problems with font loading

  bool m_initialized;

  int m_cursorId;

  int m_styleId;

  double m_pixelSize;

  std::vector<strokechar> m_string;</strokechar>

  int m_cursorIndex;  // indice del carattere successivo al cursore

  std::pair<int, int=""> m_preeditRange;</int,>

  // posizione (dentro m_string) della preeditString (cfr. IME)

  // n.b. la preeditString va da range.first a range.second-1

  TRectD m_textBox;  // bbox della stringa

  TScale m_scale;  // la dimensione dei char ottenuti dal text manager e' fissa

                   // perche' influisce sula qualita'. Quindi lo scalo

  TPointD m_cursorPoint;  // punto piu alto del cursore

  TPointD m_startPoint;   // punto dove si poggia la prima lettera (coincide col

                          // mouse click)

  double m_fontYOffset;   // spazio per le parti delle lettere sotto il rigo

                          // (dipende dal font)

  bool m_isVertical;      // text orientation

  TUndo *m_undo;

public:

  TypeTool();

  ~TypeTool();

  void updateTranslation() override;

  ToolType getToolType() const override { return TTool::LevelWriteTool; }

  void init();

  void initTypeFaces();

  void loadFonts();

  void setFont(std::wstring fontFamily);

  void setTypeface(std::wstring typeface);

  void setSize(std::wstring size);

  void setVertical(bool vertical);

  void draw() override;

  void updateMouseCursor(const TPointD &pos);

  void updateStrokeChar();

  void updateCharPositions(int updateFrom = 0);

  void updateCursorPoint();

  void updateTextBox();

  void setCursorIndexFromPoint(TPointD point);

  void mouseMove(const TPointD &pos, const TMouseEvent &) override;

  bool preLeftButtonDown() override;

  void leftButtonDown(const TPointD &pos, const TMouseEvent &) override;

  void rightButtonDown(const TPointD &pos, const TMouseEvent &) override;

  bool keyDown(QKeyEvent *event) override;

  void onInputText(const std::wstring &preedit, const std::wstring &commit,

                   int replacementStart, int replacementLen) override;

  // cancella gli StrokeChar fra from e to-1 e inserisce nuovi StrokeChar

  // corrispondenti a text a partire da from

  void replaceText(std::wstring text, int from, int to);

  void addBaseChar(std::wstring text);

  void addReturn();

  void cursorUp();

  void cursorDown();

  void cursorLeft();

  void cursorRight();

  void deleteKey();

  void addTextToImage();

  void addTextToVectorImage(const TVectorImageP ¤tImage,

                            std::vector<const *="" tvectorimage=""> &images);</const>

  void addTextToToonzImage(const TToonzImageP ¤tImage);

  void stopEditing();

  void reset() override;

  void onActivate() override;

  void onDeactivate() override;

  void onImageChanged() override;

  int getCursorId() const override {

    if (m_viewer && m_viewer->getGuidedStrokePickerMode())

      return m_viewer->getGuidedStrokePickerCursor();

    return m_cursorId;

  }

  bool onPropertyChanged(std::string propertyName) override;

  TPropertyGroup *getProperties(int targetType) override {

    return &m_prop[targetType];

  }

  int getColorClass() const { return 1; }

} typeTool;

//---------------------------------------------------------

//

// TypeTool methods

//

//---------------------------------------------------------

TypeTool::TypeTool()

    : TTool("T_Type")

    , m_textBox(TRectD(0, 0, 0, 0))

    , m_cursorPoint(TPointD(0, 0))

    , m_startPoint(TPointD(0, 0))

    , m_dimension(1)      // to be set the m_size value on the first-click

    , m_validFonts(true)  // false)

    , m_fontYOffset(0)

    , m_cursorId(ToolCursor::CURSOR_NO)

    , m_pixelSize(1)

    , m_cursorIndex(0)

    , m_preeditRange(0, 0)

    , m_isVertical(false)

    , m_initialized(false)

    , m_fontFamilyMenu("Font:")                  // W_ToolOptions_FontName

    , m_typeFaceMenu("Style:")                   // W_ToolOptions_TypeFace

    , m_vertical("Vertical Orientation", false)  // W_ToolOptions_Vertical

    , m_size("Size:")                            // W_ToolOptions_Size

    , m_undo(0) {

  bind(TTool::VectorImage | TTool::ToonzImage | TTool::EmptyTarget);

  m_prop[0].bind(m_fontFamilyMenu);

  // Su mac non e' visibile il menu dello style perche' e' stato inserito nel

  // nome

  // della font.

  //#ifndef MACOSX

  m_prop[1].bind(m_typeFaceMenu);

  //#endif

  m_prop[1].bind(m_size);

  m_prop[1].bind(m_vertical);

  m_vertical.setId("Orientation");

  m_fontFamilyMenu.setId("TypeFont");

  m_typeFaceMenu.setId("TypeStyle");

  m_size.setId("TypeSize");

}

//---------------------------------------------------------

TypeTool::~TypeTool() {}

//---------------------------------------------------------

void TypeTool::updateTranslation() {

  m_fontFamilyMenu.setQStringName(tr("Font:"));

  m_typeFaceMenu.setQStringName(tr("Style:"));

  m_vertical.setQStringName(tr("Vertical Orientation"));

  m_size.setQStringName(tr("Size:"));

}

//---------------------------------------------------------

bool TypeTool::onPropertyChanged(std::string propertyName) {

  if (!m_validFonts) return false;

  if (propertyName == m_fontFamilyMenu.getName()) {

    setFont(m_fontFamilyMenu.getValue());

    return true;

  } else if (propertyName == m_typeFaceMenu.getName()) {

    setTypeface(m_typeFaceMenu.getValue());

    return true;

  } else if (propertyName == m_size.getName()) {

    setSize(m_size.getValue());

    return true;

  } else if (propertyName == m_vertical.getName()) {

    setVertical(m_vertical.getValue());

    return true;

  }

  return false;

}

//---------------------------------------------------------

void TypeTool::init() {

  if (m_initialized) return;

  m_initialized = true;

  loadFonts();

  if (!m_validFonts) return;

  m_size.addValue(L"36");

  m_size.addValue(L"58");

  m_size.addValue(L"70");

  m_size.addValue(L"86");

  m_size.addValue(L"100");

  m_size.addValue(L"150");

  m_size.addValue(L"200");

  m_size.setValue(L"70");

}

//---------------------------------------------------------

void TypeTool::loadFonts() {

  TFontManager *instance = TFontManager::instance();

  try {

    instance->loadFontNames();

    m_validFonts = true;

  } catch (TFontLibraryLoadingError &) {

    m_validFonts = false;

    //    TMessage::error(toString(e.getMessage()));

  }

  if (!m_validFonts) return;

  std::vector<std::wstring> names;</std::wstring>

  instance->getAllFamilies(names);

  for (std::vector<std::wstring>::iterator it = names.begin();</std::wstring>

       it != names.end(); ++it)

    m_fontFamilyMenu.addValue(*it);

  std::string favFontApp     = EnvCurrentFont;

  std::wstring favouriteFont = ::to_wstring(favFontApp);

  if (m_fontFamilyMenu.isValue(favouriteFont)) {

    m_fontFamilyMenu.setValue(favouriteFont);

    setFont(favouriteFont);

  } else {

    setFont(m_fontFamilyMenu.getValue());

  }

  // not used for now

  m_scale = TScale();

  // m_scale = TScale(m_dimension /

  // (double)(TFontManager::instance()->getHeight()));

}

//---------------------------------------------------------

void TypeTool::initTypeFaces() {

  TFontManager *instance = TFontManager::instance();

  std::vector<std::wstring> typefaces;</std::wstring>

  instance->getAllTypefaces(typefaces);

  std::wstring oldTypeface = m_typeFaceMenu.getValue();

  m_typeFaceMenu.deleteAllValues();

  for (std::vector<std::wstring>::iterator it = typefaces.begin();</std::wstring>

       it != typefaces.end(); ++it)

    m_typeFaceMenu.addValue(*it);

  if (m_typeFaceMenu.isValue(oldTypeface)) m_typeFaceMenu.setValue(oldTypeface);

  TTool::getApplication()->getCurrentTool()->notifyToolComboBoxListChanged(

      m_typeFaceMenu.getName());

}

//---------------------------------------------------------

void TypeTool::setFont(std::wstring family) {

  if (m_fontFamily == family) return;

  TFontManager *instance = TFontManager::instance();

  try {

    instance->setFamily(family);

    m_fontFamily             = family;

    std::wstring oldTypeface = m_typeFaceMenu.getValue();

    initTypeFaces();

    if (oldTypeface != m_typeFaceMenu.getValue()) {

      if (m_typeFaceMenu.isValue(L"Regular")) {

        m_typeFaceMenu.setValue(L"Regular");

        m_typeface = L"Regular";

        instance->setTypeface(L"Regular");

      } else {

        m_typeface = m_typeFaceMenu.getValue();

        instance->setTypeface(m_typeface);

      }

    }

    // assert chiaramente vero se oldTypeface!=m_typeFaceMenu.getValue().

    // Assume che il TFontManager quando cambia family, si ricordi

    // il vecchio typeface e lo imposti se anche la nuova family lo ha

    assert(instance->getCurrentTypeface() == m_typeFaceMenu.getValue());

    updateStrokeChar();

    invalidate();

    EnvCurrentFont = ::to_string(m_fontFamily);

  } catch (TFontCreationError &) {

    //    TMessage::error(toString(e.getMessage()));

    assert(m_fontFamily == instance->getCurrentFamily());

    m_fontFamilyMenu.setValue(m_fontFamily);

  }

}

//---------------------------------------------------------

void TypeTool::setTypeface(std::wstring typeface) {

  if (m_typeface == typeface) return;

  TFontManager *instance = TFontManager::instance();

  try {

    instance->setTypeface(typeface);

    m_typeface = typeface;

    updateStrokeChar();

    invalidate();

  } catch (TFontCreationError &) {

    //    TMessage::error(toString(e.getMessage()));

    assert(m_typeface == instance->getCurrentTypeface());

    m_typeFaceMenu.setValue(m_typeface);

  }

}

//---------------------------------------------------------

void TypeTool::setSize(std::wstring strSize) {

  // font e tool fields update

  double dimension = std::stod(strSize);

  TImageP img      = getImage(true);

  TToonzImageP ti  = img;

  TVectorImageP vi = img;

  // for vector levels, adjust size according to the ratio between

  // the viewer dpi and the vector level's dpi

  if (vi) dimension *= Stage::inch / Stage::standardDpi;

  if (m_dimension == dimension) return;

  TFontManager::instance()->setSize((int)dimension);

  assert(m_dimension != 0);

  double ratio = dimension / m_dimension;

  m_dimension  = dimension;

  // not used for now

  m_scale = TScale();

  // m_scale = TScale(m_dimension /

  // (double)(TFontManager::instance()->getHeight()));

  // text update

  if (m_string.empty()) return;

  for (UINT i = 0; i < m_string.size(); i++) {

    if (TVectorImageP vi = m_string[i].m_char) vi->transform(TScale(ratio));

    m_string[i].m_offset *= ratio;

  }

  if (ti)

    updateStrokeChar();

  else

    updateCharPositions();

  invalidate();

}

//---------------------------------------------------------

void TypeTool::setVertical(bool vertical) {

  if (vertical == m_isVertical) return;

  m_isVertical        = vertical;

  bool oldHasVertical = TFontManager::instance()->hasVertical();

  TFontManager::instance()->setVertical(vertical);

  if (oldHasVertical != TFontManager::instance()->hasVertical())

    updateStrokeChar();

  else

    updateCharPositions();

  invalidate();

}

//---------------------------------------------------------

void TypeTool::stopEditing() {

  if (m_active == false) return;

  m_active = false;

  m_string.clear();

  m_cursorIndex = 0;

  m_textBox     = TRectD();

  //  closeImeWindow();

  //  if(m_viewer) m_viewer->enableIme(false);

  //  enableShortcuts(true);

  m_preeditRange = std::make_pair(0, 0);

  invalidate();

  if (m_undo) {

    TUndoManager::manager()->add(m_undo);

    m_undo = 0;

  }

}

//---------------------------------------------------------

void TypeTool::updateStrokeChar() {

  TFontManager *instance = TFontManager::instance();

  // not used for now

  m_scale = TScale();

  // m_scale = TScale(m_dimension / (double)(instance->getHeight()));

  bool hasKerning = instance->hasKerning();

  for (UINT i = 0; i < m_string.size(); i++) {

    if (hasKerning && i + 1 < m_string.size() && !m_string[i + 1].isReturn())

      m_string[i].update(/*m_font,*/ m_scale, m_string[i + 1].m_key);

    else

      m_string[i].update(/*m_font,*/ m_scale);

  }

  updateCharPositions();

}

//---------------------------------------------------------

void TypeTool::updateCharPositions(int updateFrom) {

  if (updateFrom < 0) updateFrom = 0;

  UINT size = m_string.size();

  TPointD currentOffset;

  TFontManager *instance = TFontManager::instance();

  m_fontYOffset          = (double)(instance->getLineSpacing()) * m_scale.a11;

  double descent         = (double)(instance->getLineDescender()) * m_scale.a11;

  double height          = (double)(instance->getHeight()) * m_scale.a11;

  double vLineSpacing =

      (double)(instance->getAverageCharWidth()) * 2.0 * m_scale.a11;

  // Update from "updateFrom"

  if (updateFrom > 0) {

    if ((int)m_string.size() <= updateFrom - 1) return;

    currentOffset = m_string[updateFrom - 1].m_charPosition - m_startPoint;

    // Vertical case

    if (m_isVertical && !instance->hasVertical()) {

      if (m_string[updateFrom - 1].isReturn())

        currentOffset = TPointD(currentOffset.x - vLineSpacing, -height);

      else

        currentOffset = currentOffset + TPointD(0, -height);

    }

    // Horizontal case

    else {

      if (m_string[updateFrom - 1].isReturn())

        currentOffset = TPointD(0, currentOffset.y - m_fontYOffset);

      else

        currentOffset =

            currentOffset + TPointD(m_string[updateFrom - 1].m_offset, 0);

    }

  }

  // Update whole characters

  else {

    if (m_isVertical && !instance->hasVertical())

      currentOffset = currentOffset + TPointD(0, -height);

    else

      currentOffset = currentOffset + TPointD(0, -descent);

  }

  for (UINT j = updateFrom; j < size; j++) {

    m_string[j].m_charPosition = m_startPoint + currentOffset;

    // Vertical case

    if (m_isVertical && !instance->hasVertical()) {

      if (m_string[j].isReturn() || m_string[j].m_key == ' ')

        currentOffset = TPointD(currentOffset.x - vLineSpacing, -height);

      else

        currentOffset = currentOffset + TPointD(0, -height);

    }

    // Horizontal case

    else {

      if (m_string[j].isReturn())

        currentOffset = TPointD(0, currentOffset.y - m_fontYOffset);

      else

        currentOffset = currentOffset + TPointD(m_string[j].m_offset, 0);

    }

  }

  // To be sure

  if (m_cursorIndex <= (int)m_string.size()) {

    updateCursorPoint();

    updateTextBox();

  }

}

//---------------------------------------------------------

void TypeTool::updateCursorPoint() {

  assert(0 <= m_cursorIndex && m_cursorIndex <= (int)m_string.size());

  TFontManager *instance = TFontManager::instance();

  double descent         = (double)(instance->getLineDescender()) * m_scale.a11;

  double height          = (double)(instance->getHeight()) * m_scale.a11;

  double vLineSpacing =

      (double)(instance->getAverageCharWidth()) * 2.0 * m_scale.a11;

  m_fontYOffset          = (double)(instance->getLineSpacing()) * m_scale.a11;

  double scaledDimension = m_dimension * m_scale.a11;

  if (m_string.empty()) {

    if (!m_isVertical || instance->hasVertical())

      m_cursorPoint = m_startPoint + TPointD(0, scaledDimension);

    else

      m_cursorPoint = m_startPoint;

  } else if (m_cursorIndex == (int)m_string.size()) {

    // Horizontal case

    if (!m_isVertical || instance->hasVertical()) {

      if (m_string.back().isReturn())

        m_cursorPoint = TPointD(

            m_startPoint.x, m_string.back().m_charPosition.y - m_fontYOffset +

                                scaledDimension + descent);

      else

        m_cursorPoint = m_string.back().m_charPosition +

                        TPointD(m_string.back().m_offset, 0) +

                        TPointD(0, scaledDimension + descent);

    }

    // Vertical case

    else {

      if (m_string.back().isReturn())

        m_cursorPoint = TPointD(m_string.back().m_charPosition.x - vLineSpacing,

                                m_startPoint.y);

      else

        m_cursorPoint = m_string.back().m_charPosition;

    }

  } else {

    if (!m_isVertical || instance->hasVertical())

      m_cursorPoint = m_string[m_cursorIndex].m_charPosition +

                      TPointD(0, scaledDimension + descent);

    else

      m_cursorPoint =

          m_string[m_cursorIndex].m_charPosition + TPointD(0, height);

  }

}

//---------------------------------------------------------

void TypeTool::updateTextBox() {

  UINT size                = m_string.size();

  UINT returnNumber        = 0;

  double currentLineLength = 0;

  double maxXLength        = 0;

  TFontManager *instance = TFontManager::instance();

  double descent         = (double)(instance->getLineDescender()) * m_scale.a11;

  double height          = (double)(instance->getHeight()) * m_scale.a11;

  double vLineSpacing =

      (double)(instance->getAverageCharWidth()) * 2.0 * m_scale.a11;

  m_fontYOffset = (double)(instance->getLineSpacing()) * m_scale.a11;

  for (UINT j = 0; j < size; j++) {

    if (m_string[j].isReturn()) {

      if (currentLineLength > maxXLength) {

        maxXLength = currentLineLength;

      }

      currentLineLength = 0;

      returnNumber++;

    } else {

      currentLineLength += (m_isVertical && !instance->hasVertical())

                               ? height

                               : m_string[j].m_offset;

    }

  }

  if (currentLineLength > maxXLength)  // last line

    maxXLength = currentLineLength;

  if (m_isVertical && !instance->hasVertical())

    m_textBox = TRectD(m_startPoint.x - vLineSpacing * returnNumber,

                       m_startPoint.y - maxXLength,

                       m_startPoint.x + vLineSpacing, m_startPoint.y)

                    .enlarge(cBorderSize * m_pixelSize);

  else

    m_textBox =

        TRectD(m_startPoint.x,

               m_startPoint.y - (m_fontYOffset * returnNumber + descent),

               m_startPoint.x + maxXLength, m_startPoint.y + height)

            .enlarge(cBorderSize * m_pixelSize);

}

//---------------------------------------------------------

void TypeTool::updateMouseCursor(const TPointD &pos) {

  int oldCursor = m_cursorId;

  if (!m_validFonts)

    m_cursorId = ToolCursor::CURSOR_NO;

  else {

    TPointD clickPoint =

        (TFontManager::instance()->hasVertical() && m_isVertical)

            ? TRotation(m_startPoint, 90) * pos

            : pos;

    if (m_textBox == TRectD(0, 0, 0, 0) || m_string.empty() ||

        !m_textBox.contains(clickPoint))

      m_cursorId = ToolCursor::TypeOutCursor;

    else

      m_cursorId = ToolCursor::TypeInCursor;