#pragma once

#ifndef TNZ_TEXTFIELD_INCLUDED

#define TNZ_TEXTFIELD_INCLUDED

#include "tw/tw.h"

#include "tw/textlistener.h"

#undef DVAPI

#undef DVVAR

#ifdef TWIN_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

#ifdef WIN32

#pragma warning(push)

#pragma warning(disable : 4251)

#endif

class DVAPI TTextField : public TWidget, public TTextListener {

public:

  class Action {

  public:

    virtual ~Action() {}

    virtual void sendCommand(std::wstring) = 0;

  };

  class Listener {

  public:

    virtual void onKeyPressed(int key){};

    virtual void onFocusChange(bool on){};

    virtual ~Listener() {}

  };

protected:

  std::wstring m_text, m_oldText;

  int m_pos;

  int m_sel0, m_sel1;

  int m_off;

  bool m_mouseDown;

  int xToIndex(int x);

  std::vector<action *=""> m_actions;</action>

  std::vector<action *=""> m_commitActions;</action>

  Listener *m_listener;

  void updateOffset();

public:

  TTextField(TWidget *parent, std::string name = "textfield");

  ~TTextField();

  virtual void commit() {}

  void draw();

  void keyDown(int, TUINT32, const TPoint &);

  void onDrop(std::wstring s);

  void leftButtonDoubleClick(const TMouseEvent &e);

  void leftButtonDown(const TMouseEvent &e);

  void leftButtonDrag(const TMouseEvent &e);

  void leftButtonUp(const TMouseEvent &e);

  std::wstring getText() const;

  void setText(std::wstring s);

  void setText(std::string s);

  // NON invoca l'azione registrata

  void select(int s0, int s1);

  void selectAll();

  void addAction(Action *action);

  void addCommitAction(Action *action);

  void setListener(Listener *listener);

  void onFocusChange(bool status);

  FocusHandling getFocusHandling() const { return LISTEN_TO_FOCUS; }

  virtual void pasteText(std::wstring text);

  virtual std::wstring copyText();

  virtual std::wstring cutText();

  virtual void drawFieldText(const TPoint &origin, std::wstring text);

#ifndef MACOSX

  // pezza dovuta al baco del gcc3.3.1. Togliere quando lo si aggiorna al 3.3.2

  // o superiori

  bool getCaret(TPoint &p, int &height);

#endif

  // toppa per aggiustare una bruttura grafica in Tab.

  // va ripensata tutta la logica del posizionamento del

  // testo

  int m_dy;

  virtual void sendCommand();

  virtual void sendCommitCommand();

};

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

template <class t=""></class>

class TTextFieldAction : public TTextField::Action {

  typedef void (T::*Method)(std::wstring text);

  T *m_target;

  Method m_method;

public:

  TTextFieldAction(T *target, Method method)

      : m_target(target), m_method(method) {}

  void sendCommand(std::wstring s) { (m_target->*m_method)(s); }

};

template <class t=""></class>

void tconnect(TTextField *fld, T *target, void (T::*method)(std::wstring s)) {

  fld->addCommitAction(new TTextFieldAction<t>(target, method));</t>

}

//===================================================================

class DVAPI TNumField : public TTextField {

public:

  class Event {

  public:

    TNumField *m_field;

    double m_value;

    enum Reason { KeyPressed, FocusChange, ReturnPressed };

    Reason m_reason;

    Event(TNumField *field)

        : m_field(field), m_value(field->getValue()), m_reason(KeyPressed) {}

  };

  class Action {

  public:

    virtual ~Action() {}

    virtual void sendCommand(const Event &ev) = 0;

  };

private:

  double m_minValue, m_maxValue;

  std::vector<action *=""> m_numActions;</action>

  bool m_isInteger;

  int m_precision;

protected:

  double m_value;

  virtual void valueToText();

  virtual void textToValue();

  void sendCommand();

public:

  TNumField(TWidget *parent, std::string name = "numfield");

  ~TNumField();

  void keyDown(int, TUINT32, const TPoint &);

  bool getIsInteger() const { return m_isInteger; }

  void setIsInteger(bool isInteger);

  void setRange(double minValue, double maxValue);

  void getRange(double &minValue, double &maxValue);

  void setPrecision(int precision) { m_precision = precision; }

  int getPrecision() { return m_precision; }

  double getValue() const { return m_value; }

  void setValue(double value);

  // NON invoca l'azione registrata

  void addAction(Action *action);

  void onFocusChange(bool status);

  void pasteText(std::wstring text);

};

template <class t=""></class>

class TNumFieldAction : public TNumField::Action {

  T *m_target;

  typedef void (T::*Method)(const TNumField::Event &e);

  Method m_method;

public:

  TNumFieldAction(T *target, Method method)

      : m_target(target), m_method(method) {}

  void sendCommand(const TNumField::Event &e) { (m_target->*m_method)(e); }

};

template <class t=""></class>

void tconnect(TNumField *nf, T *target,

              void (T::*method)(const TNumField::Event &e)) {

  nf->addAction(new TNumFieldAction<t>(target, method));</t>

}

//===================================================================

class TMeasuredValue;

class DVAPI TMeasuredValueField : public TTextField {

public:

  class Action {

  public:

    virtual ~Action() {}

    virtual void sendCommand(TMeasuredValueField *field) = 0;

  };

private:

  TMeasuredValue *m_value;

  std::vector<action *=""> m_actions;</action>

public:

  TMeasuredValueField(TWidget *parent, std::string name = "numfield");

  ~TMeasuredValueField();

  void setMeasure(std::string name);

  TMeasuredValue *getMeasuredValue() const { return m_value; }

  void setValue(double v);

  double getValue() const;

  void addAction(Action *action);

  // void onFocusChange(bool status);

  // void pasteText(wstring text);

  void commit();

};

template <class t=""></class>

class TMeasuredValueFieldAction : public TMeasuredValueField::Action {

  typedef void (T::*Method)(TMeasuredValueField *fld);

  T *m_target;

  Method m_method;

public:

  TMeasuredValueFieldAction(T *target, Method method)

      : m_target(target), m_method(method) {}

  void sendCommand(TMeasuredValueField *fld) { (m_target->*m_method)(fld); }

};

template <class t=""></class>

void tconnect(TMeasuredValueField *fld, T *target,

              void (T::*method)(TMeasuredValueField *fld)) {

  fld->addAction(new TMeasuredValueFieldAction<t>(target, method));</t>

}

#ifdef WIN32

#pragma warning(pop)

#endif

#endif