#pragma once

#ifndef GLAREA_INCLUDED

#define GLAREA_INCLUDED

//#include "traster.h"

#include "tw/tw.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 TStopWatch;

class DVAPI TGLArea : public TWidget {

  void swapBuffers();

  TStopWatch *m_stopwatch;

  double m_framePerSecond;

  void computeOcclusingRegion();

  void deleteOcclusingRegion();

  // void  redrawUncoveredArea(const TPoint &);

  std::vector<trect> *m_arrayOfRectToRedraw;</trect>

protected:

// int m_lx, m_ly;

// double m_angle;

#define PEZZA_DISABLE_REDRAW

#if defined(MACOSX) && defined(PEZZA_DISABLE_REDRAW)

  bool m_disableRedraw;

#endif

  TPoint m_lastPos;

  TPointD m_pan;  // world origin (win coords) (n. m_pan*2 are integer)

  TPointD

      m_zoomFactor;  // "world pixel" dimension (win coords) (integer if >=1)

  TDimensionD m_pixelSize;  // 1/zoomFactor; win pixel dimension (world coords)

  double m_zoomLevel;  // m_zoomFactor = e^m_zoomLevel

  // supported extensions

  static bool m_bgraSupported;

  bool m_isInsideScreen;

  void onGLContextCreated();

public:

  class PickItem {

  public:

    UINT m_label;

    UINT m_zMin;

    UINT m_zMax;

    PickItem(UINT label, UINT zmin, UINT zmax)

        : m_label(label), m_zMin(zmin), m_zMax(zmax) {}

    ~PickItem() {}

  private:

    // not implemented

    PickItem();

  };

  TGLArea(TWidget *parent, string name = "GLArea");

  ~TGLArea();

  void repaint();

  void configureNotify(const TDimension &);

  void create();

  void paintIncrementally();

  //  void rectwrite(const TRaster32P &ras, const TPoint &p);

  void over(const TRaster32P &ras, const TPoint &p);

  void over(const TRasterGR8P &ras, const TPoint &p);

  inline TPointD win2world(const TPointD &p) const;

  inline TPointD world2win(const TPointD &p) const;

  inline TAffine getWin2WorldMatrix() const;

  inline TAffine getWorld2WinMatrix() const;

  void scroll(const TPoint &d);  // viewport coordinates

  void lookAt(

      const TPointD &d);  // world coordinates of the desired window center

  // n. zoomCenter : viewport coords

  void setZoomLevel(double zlevel, const TPoint &zoomCenter);

  void changeZoomLevel(double d, const TPoint ¢er);

  virtual void onZoomChange() {}

  void fitToWindow(const TRectD &worldRect);

  void middleButtonDown(const TMouseEvent &e);

  void middleButtonDrag(const TMouseEvent &e);

  void middleButtonUp(const TMouseEvent &e);

  void draw();

  virtual void drawIncrementally();

  virtual void drawForPick() { draw(); }

  void pick(const TPoint &point, vector<pickitem> &items);</pickitem>

  double getFramePerSecond() const { return m_framePerSecond; }

  static bool isBGRASupported() { return m_bgraSupported; }

  bool unProject(TPointD &output,

                 const TPoint &mousePos, const T3DPointD &planeOrigin,

                 const T3DPointD &u, const T3DPointD &v) const;

  void makeCurrent();  // Gl context

  bool m_dontSwapBuffers;

};

inline TPointD TGLArea::win2world(const TPointD &p) const {

  TPointD q = p - m_pan;

  return TPointD(m_pixelSize.lx * q.x, m_pixelSize.ly * q.y);

}

inline TPointD TGLArea::world2win(const TPointD &p) const {

  return m_pan + TPointD(p.x * m_zoomFactor.x, p.y * m_zoomFactor.y);

}

inline TAffine TGLArea::getWin2WorldMatrix() const {

  return TScale(m_pixelSize.lx, m_pixelSize.ly) * TTranslation(-m_pan);

}

inline TAffine TGLArea::getWorld2WinMatrix() const {

  return TTranslation(m_pan) * TScale(m_zoomFactor.x, m_zoomFactor.y);

}

#endif