#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;
  std::vector<Action *> m_commitActions;
  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 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>
void tconnect(TTextField *fld, T *target, void (T::*method)(std::wstring s)) {
  fld->addCommitAction(new TTextFieldAction<T>(target, method));
}
 
//===================================================================
 
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;
  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 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>
void tconnect(TNumField *nf, T *target,
              void (T::*method)(const TNumField::Event &e)) {
  nf->addAction(new TNumFieldAction<T>(target, method));
}
 
//===================================================================
 
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;
 
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 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>
void tconnect(TMeasuredValueField *fld, T *target,
              void (T::*method)(TMeasuredValueField *fld)) {
  fld->addAction(new TMeasuredValueFieldAction<T>(target, method));
}
 
#ifdef WIN32
#pragma warning(pop)
#endif
 
#endif