#pragma once

#ifndef TRASTERIMAGE_INCLUDED

#define TRASTERIMAGE_INCLUDED

#include "timage.h"

#include "traster.h"

#undef DVAPI

#undef DVVAR

#ifdef TRASTERIMAGE_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

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

//! An image containing a raster.

/*!

  Some examples:

 \include rasterImage_ex.cpp

*/

class DVAPI TRasterImage final : public TImage {

  TRasterP m_mainRaster, m_patchRaster, m_iconRaster;

  //! dpi value for x axis

  double m_dpix,

      //! dpi value for y axis

      m_dpiy;

  //! The name of the image

  std::string m_name;

  //! The savebox of the image

  TRect m_savebox;

  // double m_hPos;

  //! Specify if the image is an opaque image.

  bool m_isOpaque;

  //! Specify if the image is a BW Scan image.

  bool m_isScanBW;

  //! The offset of the image

  TPoint m_offset;

  int m_subsampling;

public:

  TRasterImage();

  TRasterImage(const TRasterP &raster);

  ~TRasterImage();

private:

  //! Is used to clone an existing ToonzImage.

  TRasterImage(const TRasterImage &);

  //! not implemented

  TRasterImage &operator=(const TRasterImage &);

public:

  //! Return the image type

  TImage::Type getType() const override { return TImage::RASTER; }

  // image info

  //! Return the name of the image

  std::string getName() const { return m_name; }

  //! Set the name of the image

  void setName(std::string name) { m_name = name; }

  //! Get the \b dpi image

  void getDpi(double &dpix, double &dpiy) const {

    dpix = m_dpix;

    dpiy = m_dpiy;

  }

  //! Set the \b dpi image

  void setDpi(double dpix, double dpiy) {

    m_dpix = dpix;

    m_dpiy = dpiy;

  }

  int getSubsampling() const { return m_subsampling; }

  void setSubsampling(int s);

  //! Return the save box of the image

  TRect getSavebox() const { return m_savebox; }

  //! Set the save box of the image

  void setSavebox(const TRect &rect) { m_savebox = rect; }

  //! Return the bbox of the image

  TRectD getBBox() const override { return convert(m_savebox); }

  //! Return raster image offset \b m_offset

  TPoint getOffset() const { return m_offset; }

  //! Set raster image offset \b m_offset

  void setOffset(const TPoint &offset) { m_offset = offset; }

  //! Return raster hPos \b m_hPos

  // double gethPos() const {return m_hPos;}

  //! Set raster hPos \b m_hPos

  // void sethPos(double hPos) {m_hPos= hPos;}

  //! Return a clone of image

  TImage *cloneImage() const override;

  //! Return \b TRasterP

  const TRasterP &getRaster() const { return m_mainRaster; }

  //! Return \b TRasterP

  TRasterP &getRaster() { return m_mainRaster; }

  TRasterP raster() const override { return m_mainRaster; }

  //! Set the \b TRasterP \b raster

  void setRaster(const TRasterP &raster);

  //! Return a \b TRasterP contained the icon of the image \b m_iconRaster

  const TRasterP &getIconRaster() const { return m_iconRaster; }

  //! Return a \b TRasterP contained the icon of the image \b m_iconRaster

  TRasterP &getIconRaster() { return m_iconRaster; }

  //! Set a \b TRasterP contained the icon of the image \b m_iconRaster

  void setIconRaster(const TRasterP &raster) { m_iconRaster = raster; }

  //! Return true if the raster is empty

  bool isEmpty() const { return !m_mainRaster; }

  //! Return true if the raster comes from BW Scan

  bool isScanBW() const { return m_isScanBW; }

  void setScanBWFlag(bool isScanBW) { m_isScanBW = isScanBW; }

  //! Return true if the raster is opaque

  bool isOpaque() const { return m_isOpaque; }

  void setOpaqueFlag(bool isOpaque) { m_isOpaque = isOpaque; }

  //! Make the icon of the raster.

  void makeIcon(const TRaster32P &raster);

};

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

#ifdef _WIN32

template class DVAPI TSmartPointerT<trasterimage>;</trasterimage>

template class DVAPI TDerivedSmartPointerT<trasterimage, timage="">;</trasterimage,>

#endif

class DVAPI TRasterImageP final

    : public TDerivedSmartPointerT<trasterimage, timage=""> {</trasterimage,>

public:

  TRasterImageP() {}

  TRasterImageP(TRasterImage *image) : DerivedSmartPointer(image) {}

  TRasterImageP(TImageP image) : DerivedSmartPointer(image) {}

  TRasterImageP(const TRasterP &ras)

      : DerivedSmartPointer(new TRasterImage(ras)) {}

  operator TImageP() { return TImageP(m_pointer); }

};

#endif