#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;</twidget>

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

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> &);</trecti>

};

#endif