#include "ttoonzimage.h"

#include "tpalette.h"

//#include "ttile.h"

//#include "transparencyCheck.h"

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

TToonzImage::TToonzImage()

    : m_ras()

    , m_dpix(0)

    , m_dpiy(0)

    , m_subsampling(1)

    , m_name("")

    , m_savebox()

    //, m_hPos(0.0)

    , m_offset(0, 0)

    , m_size() {}

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

TToonzImage::TToonzImage(const TRasterCM32P &ras, const TRect &saveBox)

    : m_ras(ras)

    , m_size(ras->getSize())

    , m_dpix(0)

    , m_dpiy(0)

    , m_subsampling(1)

    , m_name("")

    , m_savebox(saveBox)

    //, m_hPos(0.0)

    , m_offset(0, 0) {

  assert(ras->getBounds().contains(saveBox));

}

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

TToonzImage::TToonzImage(const TToonzImage &src)

    : m_ras(TRasterCM32P())

    , m_dpix(src.m_dpix)

    , m_dpiy(src.m_dpiy)

    , m_subsampling(src.m_subsampling)

    , m_name(src.m_name)

    , m_savebox(src.m_savebox)

    //, m_hPos(src.m_hPos)

    , m_offset(src.m_offset)

    , m_size(src.m_size) {

  if (src.m_ras)  // src non e' compressa

  {

    m_ras = src.m_ras->clone();

  } else {

    assert(false);

    assert(!src.m_ras);

  }

  TPalette *palette = src.getPalette();

  if (palette) {

    m_palette = palette->clone();

    m_palette->addRef();

  } else

    m_palette = 0;

}

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

TToonzImageP TToonzImage::clone() const { return TToonzImageP(cloneImage()); }

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

TToonzImage::~TToonzImage() {}

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

TImage *TToonzImage::cloneImage() const { return new TToonzImage(*this); }

//=========================================================

void TToonzImage::setSubsampling(int s) { m_subsampling = s; }

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

void TToonzImage::setSavebox(const TRect &rect) {

  QMutexLocker sl(&m_mutex);

  // assert(m_lockCount>0);

  assert(m_ras);

  m_savebox = TRect(m_size) * rect;

  assert(TRect(m_size).contains(m_savebox));

}

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

namespace {

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

// il clipRect fa riferimento alle coordinate di rasIn

// se clipRect.isEmpty() allora aggiorna tutto

/*

void doUpdateRas32(const TRaster32P   &rasOut,

                   const TRasterCM32P &rasIn,

                   TPaletteP palette,

                   const TRect &theClipRect,

                                                                         bool

transparencyCheck,

                                                                         bool

applyFx)

{

  assert(palette);

  assert(rasIn && rasOut);

  applyFx = true;

  TRect clipRect(theClipRect);

  if(clipRect.isEmpty())

    clipRect = rasIn->getBounds();

  else

    {

     if(!clipRect.overlaps(rasIn->getBounds())) return;

     clipRect = clipRect * rasIn->getBounds();

    }

  if (clipRect.isEmpty())

    return;

        TRect clipRectIn, clipRectOut;

        if (applyFx && palette->getFxRects(clipRect, clipRectIn, clipRectOut))

          {

                TRect rAux = clipRectIn;

                TRasterP rAuxIn = rasIn->extract(clipRectIn);

                if (rAux!=clipRectIn && rAux!=rasIn->getBounds())

                  {

                        TRasterCM32P rNew(rAux.getSize());

                        TRect tmpRect = clipRectIn - rAux.getP00();

      rNew->extract(tmpRect)->copy(rAuxIn);

      rAuxIn = rNew;

                        clipRectIn = rAux;

                        }

    TTile tileIn(rAuxIn, convert(clipRectIn.getP00()));

                rAux = clipRectOut;

    TRasterP rAuxOut = rasOut->extract(clipRectOut);

    TTile tileOut(rAuxOut, convert(clipRectOut.getP00()));

    TRop::convert(tileOut, tileIn, palette, transparencyCheck, true);

    }

        else

          {

                TRect clipRectIn = clipRect;

                TRect clipRectOut = clipRect;

                TRasterP _rasOut = rasOut->extract(clipRectOut);

                TRasterP _rasIn;

                _rasIn = rasIn->extract(clipRectIn);

    TRop::convert(TTile(_rasOut, convert(clipRectOut.getP00())),

                              TTile(_rasIn,  convert(clipRectIn.getP00())),

                                                                        palette,

transparencyCheck, false);

                }

}

*/

}  // anonymous namespace

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

/*

TRaster32P TToonzImage::getRGBM(bool readOnly, bool computeFx)

{

  if (readOnly)

  {

    QMutexLocker sl(m_mutex);

    if (m_ras32)

      return m_ras32->clone();

    TRasterCM32P rasCM32;

    if (m_ras)

      rasCM32 = m_ras;

    else

      rasCM32 = getCMapped(true);

    assert(rasCM32);

    TPalette *palette = getPalette();

    assert(palette);

    TRaster32P ras32(rasCM32->getSize());

    const TPixel32 bgColor(255,255,255,0);

    ras32->fillOutside(m_savebox, bgColor);

    doUpdateRas32(ras32, rasCM32, palette, m_savebox, false, computeFx);

    return ras32;

  }

  else

  {

    QMutexLocker sl(m_mutex);

    return m_ras32;

  }

}

*/

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

TRasterCM32P TToonzImage::getCMapped(/*bool readOnly*/) const {

  /*

if (readOnly)

{

{

QMutexLocker sl(m_mutex);

if (m_ras)

  return m_ras->clone();

}

return decompress();

}

else

*/

  {

    // QMutexLocker sl(&m_mutex);

    return m_ras;

  }

}

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

void TToonzImage::setCMapped(const TRasterCM32P &ras) {

  QMutexLocker sl(&m_mutex);

  m_ras     = ras;

  m_size    = ras->getSize();

  m_savebox = ras->getBounds();

  // delete [] m_compressedBuffer;

  // m_compressedBuffer = 0;

  // m_compressedBufferSize = 0;

}

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

void TToonzImage::getCMapped(const TRasterCM32P &ras) {

  assert(ras && ras->getSize() == m_size);

  QMutexLocker sl(&m_mutex);

  if (m_ras) ras->copy(m_ras);

  /*

else

decompress(ras);

*/

}