#pragma once

#ifndef TW_INCLUDED
#define TW_INCLUDED

#include "traster.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

class TMouseEvent;
class TCursor;
class TDragDropListener;

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

class DVAPI TGuiColor {
  int m_red, m_green, m_blue;
  // mutable void* m_imp;
  // bool  m_isStock;
  // int m_shade;

  // TUINT32 *m_index;
  // mutable bool m_allocated;
public:
  // static const int m_maxShade;

  TGuiColor(int r, int g, int b);
  TGuiColor();
  ~TGuiColor();

  // TGuiColor(const TGuiColor&);
  // TGuiColor& operator=(const TGuiColor&);

  // TUINT32 getIndex(int shade=0) const;
  // TUINT32 getRGB(int shade=0) const;

  int red() const { return m_red; }
  int green() const { return m_green; }
  int blue() const { return m_blue; }

  void computeShade(int index, int &r, int &g, int &b) const;

  // void* imp() const {return m_imp;}
  // void imp(void* imp) const { m_imp = imp; }
  // bool isStock() const { return m_isStock; }

protected:
  void initStockColor();
};

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

class TWidgetImp;

// class TTarget {};
// class TTimerTarget {};

class TWidget;
typedef std::vector<TWidget *> TWidgetList;

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

class DVAPI TWidget
// : public TTarget, public TTimerTarget
{
public:
  enum Alignment { BEGIN, CENTER, END };
  enum FocusHandling { IGNORE_FOCUS, STOP_FOCUS, LISTEN_TO_FOCUS };

protected:
  TRect m_placement;
  int m_xoff, m_yoff;

  bool m_mapped;  // e' arrivato il MapNotify
  bool m_hidden;  // il widget non vuole mostrarsi
  bool m_childrenChanged;

  // TTimer *m_timer;

  TWidget *m_parent, *m_sonKeeper;
  std::string m_name, m_contextHelpReference;
  std::wstring m_shortHelp, m_longHelp;

  int m_cursorIdx;

  TWidgetList *m_sons;
  TWidgetImp *m_imp;

  friend class TWidgetImp;

  TGuiColor m_backgroundColor, m_foregroundColor;
  bool m_popupMode, m_menuMode, m_fixedSize, m_fullColor, m_openGL;
  bool m_enabled, m_menuRelated;

  TDragDropListener *m_dragDropListener;

  std::string m_fontName;
  int m_fontSize;
  int m_fontOrientation;

  static TWidget *m_selectionOwner;
  static TWidget *m_focusOwner;

  // not implemented (cannot copy and assign widget)
private:
  TWidget(const TWidget &);
  TWidget &operator=(const TWidget &);

protected:
  virtual void create();
  virtual void setDecoration();
  virtual void destroyImp();
  void createSons();

public:
  TWidget(TWidget *parent = 0, std::string name = "unnamed");
  virtual ~TWidget();

  //
  // geometry
  //
  const TRect &getGeometry() const { return m_placement; }
  TPoint getPosition() const { return m_placement.getP00(); }
  virtual TPoint getHotSpot() const { return TPoint(0, 0); }
  TDimension getSize() const { return m_placement.getSize(); }
  TRect getBounds() const { return TRect(TPoint(), getSize()); }
  int getLx() const { return m_placement.getLx(); }
  int getLy() const { return m_placement.getLy(); }

  inline void setPlacement(const TRect &rect) { m_placement = rect; }

  inline void setGeometry(int x0, int y0, int x1, int y1) {
    setGeometry(TRect(x0, y0, x1, y1));
  }

  virtual void setGeometry(const TRect &rect);
  void setGeometry(const TPoint &pos, const TDimension &size) {
    setGeometry(TRect(pos, size));
  }
  inline void setSize(int w, int h) {
    setGeometry(getPosition(), TDimension(w, h));
  }

  inline void setSize(const TDimension &size) { setSize(size.lx, size.ly); }
  inline void setPosition(int x, int y) {
    setGeometry(TPoint(x, y), getSize());
  }
  inline void setPosition(const TPoint &pt) { setGeometry(pt, getSize()); }
  inline bool contains(int x, int y) const { return contains(TPoint(x, y)); }
  inline bool contains(const TPoint &p) const {
    return m_placement.contains(p);
  }

  TPoint getScreenPosition() const;

  //
  // name, parent & sons
  //
  inline TWidget *getParent() const { return m_parent; }
  inline std::string getName() const { return m_name; }
  virtual void setParent(TWidget *p);
  virtual void addSon(TWidget *son);
  virtual void removeSon(TWidget *son);
  inline int getSonCount() const { return m_sons->size(); }
  inline TWidget *getSon(int i) const {
    return i < 0 || i >= (int)(m_sons->size()) ? 0 : (*m_sons)[i];
  }

  //
  // help messages
  //
  std::wstring getLongHelp() const;
  std::wstring getShortHelp() const;

  void setHelp(std::string shortHelp, std::string longHelp);
  void setHelp(std::wstring shortHelp, std::wstring longHelp);

  virtual std::string getContextHelpReference(const TPoint &) {
    return m_contextHelpReference;
  }

  void setContextHelpReference(std::string s) { m_contextHelpReference = s; }

  // void delegateHelpToParent();

  virtual std::wstring getTooltipString(const TPoint &) {
    return getShortHelp();
  }

  //
  // misc
  //
  inline bool isHidden() const { return m_hidden; }
  inline bool isMapped() const { return m_mapped; }

  void enable();
  void disable();
  inline bool isEnabled() const { return m_enabled; }

  void show();
  void hide();

  // n.b. non chiamare map/unmap, ma show/hide
  virtual void map();
  virtual void unmap();

  virtual void doModal();

  virtual void undock();
  virtual void dock(TWidget *parent);
  virtual TWidget *findSubWidget(const TPoint &pt);

  virtual void repaint();

  void sendRepaint() { sendRepaint(getBounds()); }
  void sendRepaint(const TRect &);

  virtual void paste();

  virtual void startDragAndDrop(std::string stringToDrop);

  typedef unsigned int CursorIndex;

  inline CursorIndex getCurrentCursor() { return m_cursorIdx; }
  void changeCursor(CursorIndex new_cur);

  TWidgetImp *getImp() { return m_imp; }

  void startTimer(TINT32 period);
  void stopTimer();

  virtual void getSelection();

  virtual void onFocusChange(bool on);

  virtual bool getFocus() { return false; }
  virtual void circulateFocus();

  virtual void copyRegion(const TPoint &dst, const TPoint &src,
                          const TDimension &size);

  //
  // draw
  //
  void flush();

  virtual void draw() {}
  virtual void invalidate();
  virtual void invalidate(const TRect &rect);

  void getClipRect(TRect &rect);

  virtual void clear();

  virtual void drawText(const TPoint &p, std::string text);
  virtual void drawText(const TPoint &p, std::wstring text);

  virtual void drawText(const TRect &r, std::string text,
                        Alignment alignment = CENTER);
  virtual void drawText(const TRect &r, std::wstring text,
                        Alignment alignment = CENTER);
  virtual void drawMultiLineText(const TRect &r, std::string text);
  virtual void drawMultiLineText(const TRect &r, std::wstring text);

  virtual TDimension getTextSize(std::string text);
  virtual TDimension getTextSize(std::wstring text);

  virtual TDimension getTextSize(std::string text, std::string font,
                                 int fontSize);
  virtual TDimension getTextSize(std::wstring text, std::string font,
                                 int fontSize);

  inline void drawPoint(int x, int y) { drawLine(x, y, x, y); }

  virtual void drawLine(const TPoint &p0, const TPoint &p1);
  inline void drawLine(int x0, int y0, int x1, int y1) {
    drawLine(TPoint(x0, y0), TPoint(x1, y1));
  }
  virtual void drawVLine(const TPoint &p0, int length) {
    drawLine(p0, p0 + TPoint(0, length - 1));
  }
  virtual void drawHLine(const TPoint &p0, int length) {
    drawLine(p0, p0 + TPoint(length - 1, 0));
  }

  virtual void drawDottedLine(const TPoint &p0, const TPoint &p1);
  inline void drawDottedLine(int x0, int y0, int x1, int y1) {
    drawDottedLine(TPoint(x0, y0), TPoint(x1, y1));
  }

  virtual void drawRect(const TRect &);
  virtual void fillRect(const TRect &);

  virtual void drawRect(int x0, int y0, int x1, int y1) {
    drawRect(TRect(x0, y0, x1, y1));
  }
  virtual void fillRect(int x0, int y0, int x1, int y1) {
    fillRect(TRect(x0, y0, x1, y1));
  }

  virtual void draw3DRect(const TRect &, bool pressed = false, int border = 1);
  virtual void fill3DRect(const TRect &, bool pressed = false, int border = 1);

  virtual void drawDottedRect(const TRect &);
  virtual void drawDottedRect(int x0, int y0, int x1, int y1) {
    drawDottedRect(TRect(x0, y0, x1, y1));
  }

  virtual void fillPolygon(const TGuiColor &fillColor,
                           const TGuiColor &borderColor, const TPoint points[],
                           int pointCount);

  virtual void clear(const TRect &);

  virtual void drawImage(int index, const TPoint &);

  virtual void setColor(const TGuiColor &, int shade = 0);
  virtual void setBackgroundColor(const TGuiColor &);

  TGuiColor getBackgroundColor() const { return m_backgroundColor; }
  TGuiColor getForegroundColor() const { return m_foregroundColor; }

  static const TGuiColor White;
  static const TGuiColor Black;

  virtual void rectwrite(const TRaster32P &, const TPoint &);

  virtual void setFontSize(int size);
  virtual void setFont(std::string name, int size = 0, int orientation = 0);

  //
  // events
  //

  virtual void enter(const TPoint &) {}
  virtual void leave(const TPoint &) {}

  virtual void mouseMove(const TMouseEvent &) {}
  virtual void leftButtonDown(const TMouseEvent &) {}
  virtual void leftButtonDrag(const TMouseEvent &) {}
  virtual void leftButtonUp(const TMouseEvent &) {}
  virtual void rightButtonDown(const TMouseEvent &) {}
  virtual void rightButtonDrag(const TMouseEvent &) {}
  virtual void rightButtonUp(const TMouseEvent &) {}
  virtual void middleButtonDown(const TMouseEvent &) {}
  virtual void middleButtonDrag(const TMouseEvent &) {}
  virtual void middleButtonUp(const TMouseEvent &) {}
  virtual void leftButtonDoubleClick(const TMouseEvent &) {}
  virtual void middleButtonDoubleClick(const TMouseEvent &) {}
  virtual void rightButtonDoubleClick(const TMouseEvent &) {}

  virtual void mouseWheel(const TMouseEvent &, int wheel) {}

  virtual void keyDown(int, TUINT32, const TPoint &) {}

  virtual void configureNotify(const TDimension &) {}

  virtual void onPaste(std::string) {}

  // virtual void close() {unmap();}

  virtual void onDrop(std::string) {}

  virtual std::string getToolTip() { return ""; }

  virtual void onTimer(int) {}

  virtual void onChildrenChanged() {}

  virtual bool onNcPaint(bool is_active, const TDimension &window_size,
                         const TRect &caption_rect);

public:
  static void setFocusOwner(TWidget *w);
  static TWidget *getFocusOwner();

  virtual FocusHandling getFocusHandling() const { return IGNORE_FOCUS; }

  static void placeInteractively(TRect &);

  // brutto brutto qui
  virtual void maximize(TWidget *) {}
  virtual bool isMaximized(TWidget *) { return false; }

  //
  // drag & drop
  //
  // virtual bool acceptDrop() {return false;}
  void enableDropTarget(TDragDropListener *dragDropListener);
  TDragDropListener *getDragDropListener() const { return m_dragDropListener; }

  static void yield();  // processa tutti gli eventi in attesa
  static void setMode(int mode);

  // misc
  TPoint getAbsolutePosition() const;
  static TPoint getMouseAbsolutePosition();
  TPoint getMouseRelativePosition() const;

  // brutto. serve per filtrare gli eventi durante il menu event loop
  bool isMenuRelated() const { return m_menuRelated; }

  // se non altro e' brutto il nome
  // NB: il nome e' brutto... ora questo e' anche sbagliato
  static void processAllPendingMessages();  // questa processa solo i WM_PAINT

  static void processAllPendingMessages2();  // questa processa tutto

  // mah? serve a evitare il circuito invalidate() -> repaint(); chiama
  // direttamente
  // repaint() (creando l'opportuno GC su windows)
  // void paintRegion(const TRect &rect);

  static TDimension getScreenSize();
  static void getScreenPlacement(std::vector<TRectI> &);
};

#endif