#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);

*/

}