//=============================================================================
//
//   File : KvsObject_pixmap.cpp
//   Creation date : Fri Mar 18 14:30:48 CEST 2005
//   by Tonino Imbesi(Grifisx) and Alessandro Carbone(Noldor)
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2005-2008 Alessandro Carbone (elfonol at gmail dot com)
//
//   This program is FREE software. You can redistribute it and/or
//   modify it under the terms of the GNU General Public License
//   as published by the Free Software Foundation; either version 2
//   of the License, or (at your option) any later version.
//
//   This program is distributed in the HOPE that it will be USEFUL,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//   See the GNU General Public License for more details.
//
//   You should have received a copy of the GNU General Public License
//   along with this program. If not, write to the Free Software Foundation,
//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================

#include "KvsObject_pixmap.h"
#include "KvsObject_widget.h"

#include "KvsObject_memoryBuffer.h"
#include "KviAnimatedPixmap.h"

#include "kvi_debug.h"
#include "KviLocale.h"

#include <QFile>

/*
	@doc: pixmap
	@keyterms:
	    pixmap object class
	@title:
		pixmap class
	@type:
		class
	@short:
		This class provide a pixmap.
	@inherits:
		[class]object[/class]
		[class]widget[/class]
	@description:
		The pixmap class is an off-screen, pixel-based paint device.
	@functions:
		!fn: $fill(<colorname, RGB or HSV array value or [<red>, <green>, <blue>][<hue>, <saturation>, <value>], [opacity], [system color:RGB or HSV])
		Fills the pixmap with color and opacity.[br]
		!fn: $resize(<width:integer>,<height:integer>)
		Resizes the pixmap to w width and h height. Set [b]wh[/b] or [b]hg to [b]0[/b], to have a null pixmap.
		!fn: $scale(<width:integer>,<height:integer>,[<aspect_ratio:string>])
		Scales the pixmap or the animation by [b]sx[/b] horizontally and [b]sy[/b] vertically.[br]
		Aspect_ratio values:
		[pre]
			- IgnoreAspectRatio:the pixmap is scaled ignoring his aspect ratio.
			- KeepAspectRatio: pixmap is scaled to a rectangle as large as possible inside size, preserving the aspect ratio.
			- KeepAspectRatioByExpanding, the pixmap is scaled to a rectangle as small as possible outside size, preserving the aspect ratio.
		[/pre]
		[b]Default value is KeepAspectRatio.[/b][br][br]
		!fn: $load(<file_name:string>)
		Load a pixmap from the file <file_name>.
		!fn: $save(<file_name:string>)
		Save the pixmap or the current animation frame to the file <file_name>.
		!fn: $loadAnimation(<file_name:string>)
		Load an animation from the file <file_name> and start it.
		!fn: $startAnimation()
		Start the animation.
		!fn: $stopAnimation()
		Stop the animation.
		!fn: <integer> $height()
		Return the height of the pixmap or of the animation.
		!fn: <integer> $width()
		Return the width of the pixmap or of the animation.
		!fn: $frameChangedEvent()
		This event is triggered by KVIrc when the current animation frame changes.
	@signals:
		!sg: $frameChanged()
		This signal is emitted by the default implementation of [classfnc]$frameChangedEvent[/classfnc]().[br]
*/

KVSO_BEGIN_REGISTERCLASS(KvsObject_pixmap, "pixmap", "object")

KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, fill)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, resize)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, scale)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, load)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, loadAnimation)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, save)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, startAnimation)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, stopAnimation)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, loadFromMemoryBuffer)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, height)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, width)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, rotate)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, mirrored)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, setPixel)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, pixel)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, grabWidget)
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_pixmap, frameChangedEvent)

KVSO_END_REGISTERCLASS(KvsObject_pixmap)

KVSO_BEGIN_CONSTRUCTOR(KvsObject_pixmap, KviKvsObject)
m_pAnimatedPixmap = nullptr;
m_currentType = Image;
m_pPixmap = nullptr;
m_pImage = nullptr;
KVSO_END_CONSTRUCTOR(KvsObject_pixmap)

KVSO_BEGIN_DESTRUCTOR(KvsObject_pixmap)
emit aboutToDie();
if(m_pPixmap)
	delete m_pPixmap;
if(m_pAnimatedPixmap)
	delete m_pAnimatedPixmap;
if(m_pImage)
	delete m_pImage;
KVSO_END_CONSTRUCTOR(KvsObject_pixmap)

KVSO_CLASS_FUNCTION(pixmap, fill)
{
	kvs_int_t iCol1, iCol2, iCol3, iOpacity;
	QString szColorMode, szColor;
	KviKvsVariant *var1, *var2, *var3;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("Color_1_Or_Colorname", KVS_PT_VARIANT, 0, var1)
	KVSO_PARAMETER("Color_2", KVS_PT_VARIANT, KVS_PF_OPTIONAL, var2)
	KVSO_PARAMETER("Colo3_3", KVS_PT_VARIANT, KVS_PF_OPTIONAL, var3)
	KVSO_PARAMETER("color_mode", KVS_PT_STRING, KVS_PF_OPTIONAL, szColorMode)
	KVSO_PARAMETER("opacity", KVS_PT_INT, KVS_PF_OPTIONAL, iOpacity)
	KVSO_PARAMETERS_END(c)

	QColor col;
	if(!var1->asInteger(iCol1))
	{
		var1->asString(szColor);
		if(c->paramCount() < 2)
			iOpacity = 255;
		else
		{
			if(!var2->asInteger(iOpacity))
			{
				c->warning(__tr2qs_ctx("The opacity parameter didn't evaluate to integer", "objects"));
				return true;
			}
		}
		col.setNamedColor(szColor);
		col.setAlpha(iOpacity);
	}
	else
	{
		if(c->paramCount() < 3)
		{
			c->error(__tr2qs_ctx("Color name or triplet RGB/HSV value required", "objects"));
			return true;
		}
		if(!var2->asInteger(iCol2) || !var3->asInteger(iCol3))
		{
			c->error(__tr2qs_ctx("One of the triplet parameters didn't evaluate to an integer", "objects"));
			return true;
		}
		if(c->paramCount() < 5)
			iOpacity = 255;

		if(KviQString::equalCI(szColorMode, "HSV"))
			col.setHsv(iCol1, iCol2, iCol3, iOpacity);
		else
			col.setRgb(iCol1, iCol2, iCol3, iOpacity);
	}
	if(m_currentType == Image)
	{
		if(m_pImage)
		{
			if(!m_pPixmap)
				m_pPixmap = new QPixmap();
			*m_pPixmap = QPixmap::fromImage(*m_pImage);
			delete m_pImage;
			m_pImage = nullptr;
		}
		else
		{
			m_pPixmap = nullptr;
		}
	}
	else if(m_currentType == AnimatedPixmap)
	{
		delete m_pAnimatedPixmap;
		m_pAnimatedPixmap = nullptr;
	}
	m_currentType = Pixmap;
	if(!m_pPixmap)
		m_pPixmap = new QPixmap();
	m_pPixmap->fill(col);
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, resize)
{
	kvs_int_t iWidth, iHeight;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("width", KVS_PT_INTEGER, 0, iWidth)
	KVSO_PARAMETER("height", KVS_PT_INTEGER, 0, iHeight)
	KVSO_PARAMETERS_END(c)

	if(m_currentType == Image)
	{
		if(m_pImage)
		{
			delete m_pImage;
			m_pImage = nullptr;
		}
	}
	else if(m_currentType == AnimatedPixmap)
	{
		if(m_pAnimatedPixmap)
		{
			delete m_pAnimatedPixmap;
			m_pAnimatedPixmap = nullptr;
		}
	}
	else if(m_pPixmap)
	{
		delete m_pPixmap;
	}
	m_currentType = Image;
	m_pImage = new QImage(iWidth, iHeight, QImage::Format_ARGB32_Premultiplied);
	m_pImage->fill(Qt::transparent);
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, setPixel)
{
	kvs_int_t iCol1, iCol2, iCol3, iOpacity, iX, iY;
	QString szColorMode, szColor;
	KviKvsVariant *var1, *var2, *var3;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("x", KVS_PT_INTEGER, 0, iX)
	KVSO_PARAMETER("y", KVS_PT_INTEGER, 0, iY)
	KVSO_PARAMETER("Color_1_Or_Colorname", KVS_PT_VARIANT, 0, var1)
	KVSO_PARAMETER("Color_2", KVS_PT_VARIANT, KVS_PF_OPTIONAL, var2)
	KVSO_PARAMETER("Colo3_3", KVS_PT_VARIANT, KVS_PF_OPTIONAL, var3)
	KVSO_PARAMETER("color_mode", KVS_PT_STRING, KVS_PF_OPTIONAL, szColorMode)
	KVSO_PARAMETER("opacity", KVS_PT_INT, KVS_PF_OPTIONAL, iOpacity)
	KVSO_PARAMETERS_END(c)

	QColor col;
	if(!var1->asInteger(iCol1))
	{
		var1->asString(szColor);
		if(c->paramCount() < 4)
		{
			iOpacity = 255;
		}
		else
		{
			if(!var2->asInteger(iOpacity))
			{
				c->warning(__tr2qs_ctx("The opacity parameter didn't evaluate to integer", "objects"));
				return true;
			}
		}
		col.setNamedColor(szColor);
		col.setAlpha(iOpacity);
	}
	else
	{
		if(c->paramCount() < 5)
		{
			c->error(__tr2qs_ctx("Color name or triplet RGB/HSV value required", "objects"));
			return true;
		}
		if(!var2->asInteger(iCol2) || !var3->asInteger(iCol3))
		{
			c->error(__tr2qs_ctx("One of the triplet parameters didn't evaluate to an integer", "objects"));
			return true;
		}
		if(c->paramCount() < 7)
			iOpacity = 255;

		if(KviQString::equalCI(szColorMode, "HSV"))
			col.setHsv(iCol1, iCol2, iCol3, iOpacity);
		else
			col.setRgb(iCol1, iCol2, iCol3, iOpacity);
	}

	if(m_currentType == AnimatedPixmap)
	{
		c->warning(__tr2qs_ctx("AnimatedPixmap not supported", "objects"));
		return true;
	}
	else if((m_currentType == Image && !m_pImage) || (m_currentType == Pixmap && !m_pPixmap))
	{
		c->error(__tr2qs_ctx("The pixmap is null", "objects"));
		return false;
	}
	else if(m_currentType == Pixmap)
	{
		delete m_pImage;
		m_pImage = new QImage();
		*m_pImage = m_pPixmap->toImage();
		delete m_pPixmap;
	}
	m_currentType = Image;
	m_pImage->setPixel(iX, iY, col.rgba());
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, pixel)
{
	kvs_int_t iX, iY;
	QString szFlags;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("x", KVS_PT_INTEGER, 0, iX)
	KVSO_PARAMETER("y", KVS_PT_INTEGER, 0, iY)
	KVSO_PARAMETER("b", KVS_PT_STRING, KVS_PF_OPTIONAL, szFlags)
	KVSO_PARAMETERS_END(c)

	if(m_currentType == AnimatedPixmap)
	{
		c->warning(__tr2qs_ctx("AnimatedPixmap not supported", "objects"));
		return true;
	}
	else if((m_currentType == Image && !m_pImage) || (m_currentType == Pixmap && !m_pPixmap))
	{
		c->error(__tr2qs_ctx("The pixmap is null", "objects"));
		return false;
	}
	else if(m_currentType == Pixmap)
	{
		// 		qDebug("mpimage %i",m_pImage);
		// 		qDebug("pixmap %i %i",m_pPixmap->width(),m_pPixmap->height());
		delete m_pImage;
		m_pImage = new QImage();
		*m_pImage = m_pPixmap->toImage();
		delete m_pPixmap;
		m_pPixmap = nullptr;
	}
	m_currentType = Image;
	QRgb rgb = m_pImage->pixel(iX, iY);
	QColor col(rgb);
	if(szFlags.isEmpty())
	{
		c->returnValue()->setString(col.name());
		return true;
	}
	if(szFlags.indexOf('a', 0, Qt::CaseInsensitive) != -1)
	{
		KviKvsArray * pArray = new KviKvsArray();
		pArray->set(0, new KviKvsVariant((kvs_int_t)col.red()));
		pArray->set(1, new KviKvsVariant((kvs_int_t)col.green()));
		pArray->set(2, new KviKvsVariant((kvs_int_t)col.blue()));
		c->returnValue()->setArray(pArray);
	}
	else if(szFlags.indexOf('h', 0, Qt::CaseInsensitive) != -1)
	{
		KviKvsHash * pHash = new KviKvsHash();
		pHash->set("red", new KviKvsVariant((kvs_int_t)col.red()));
		pHash->set("green", new KviKvsVariant((kvs_int_t)col.green()));
		pHash->set("blue", new KviKvsVariant((kvs_int_t)col.blue()));
		c->returnValue()->setHash(pHash);
	}
	return true;
}
KVSO_CLASS_FUNCTION(pixmap, rotate)
{
	kvs_real_t dAngle;
	QString szAxis;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("angle", KVS_PT_DOUBLE, 0, dAngle)
	KVSO_PARAMETER("axis", KVS_PT_STRING, KVS_PF_OPTIONAL, szAxis)
	KVSO_PARAMETERS_END(c)

	Qt::Axis axis = Qt::ZAxis;
	if(!szAxis.isEmpty())
	{
		if(KviQString::equalCI(szAxis, "XAxis"))
			axis = Qt::XAxis;
		else if(KviQString::equalCI(szAxis, "YAxis"))
			axis = Qt::YAxis;
		else if(KviQString::equalCI(szAxis, "ZAxis"))
			axis = Qt::ZAxis;
		else
			c->warning(__tr2qs_ctx("Unknown axis '%Q' switching to default ZAxis", "objects"), &szAxis);
	}

	if(m_currentType == Pixmap)
	{
		if(m_pPixmap)
		{
			if(!m_pImage)
				m_pImage = new QImage();
			*m_pImage = m_pPixmap->toImage();
		}
		else
		{
			c->error(__tr2qs_ctx("The pixmap is null", "objects"));
			return false;
		}
	}
	else if(m_currentType == AnimatedPixmap)
	{
		c->warning(__tr2qs_ctx("AnimatedPixmap not supported", "objects"));
		return true;
	}

	if(!m_pImage)
	{
		c->error(__tr2qs_ctx("The pixmap is null", "objects"));
		return false;
	}
	m_currentType = Image;
	QTransform transform;
	transform.rotate(dAngle, axis);
	*m_pImage = m_pImage->transformed(transform);
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, mirrored)
{
	bool bHorizontal, bVertical;

	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("bHorizontal", KVS_PT_BOOLEAN, 0, bHorizontal)
	KVSO_PARAMETER("bVertical", KVS_PT_BOOLEAN, 0, bVertical)
	KVSO_PARAMETERS_END(c)
	if(m_currentType == Pixmap)
	{
		if(m_pPixmap)
		{
			if(!m_pImage)
				m_pImage = new QImage();
			*m_pImage = m_pPixmap->toImage();
		}
		else
		{
			c->error(__tr2qs_ctx("The pixmap is null", "objects"));
			return false;
		}
	}
	else if(m_currentType == AnimatedPixmap)
	{
		c->warning(__tr2qs_ctx("AnimatedPixmap not supported", "objects"));
		return true;
	}

	if(!m_pImage)
	{
		c->error(__tr2qs_ctx("The pixmap is null", "objects"));
		return false;
	}
	m_currentType = Image;
	*m_pImage = m_pImage->mirrored(bHorizontal, bVertical);
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, scale)
{
	kvs_int_t iWidth, iHeight;
	QString szAspectRatio;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("width", KVS_PT_INTEGER, 0, iWidth)
	KVSO_PARAMETER("height", KVS_PT_INTEGER, 0, iHeight)
	KVSO_PARAMETER("aspect_ratio", KVS_PT_STRING, KVS_PF_OPTIONAL, szAspectRatio)
	KVSO_PARAMETERS_END(c)
	Qt::AspectRatioMode ratio = Qt::KeepAspectRatio;
	if(!szAspectRatio.isEmpty())
	{
		if(KviQString::equalCI(szAspectRatio, "IgnoreAspectRatio"))
			ratio = Qt::IgnoreAspectRatio;
		else if(KviQString::equalCI(szAspectRatio, "KeepAspectRatio"))
			ratio = Qt::KeepAspectRatio;
		else if(KviQString::equalCI(szAspectRatio, "KeepAspectRatioByExpanding"))
			ratio = Qt::KeepAspectRatioByExpanding;
		else
			c->warning(__tr2qs_ctx("Unknown aspect ratio %Q - Switching to KeepAspectRatio ratio", "objects"), &szAspectRatio);
	}
	if(m_currentType == Pixmap)
	{
		if(m_pPixmap)
			*m_pPixmap = m_pPixmap->scaled(iWidth, iHeight, ratio, Qt::SmoothTransformation);
		else
		{
			c->error(__tr2qs_ctx("The pixmap is null", "objects"));
			return false;
		}
	}
	else if(m_currentType == AnimatedPixmap)
		m_pAnimatedPixmap->resize(QSize(iWidth, iHeight), ratio);
	else if(m_currentType == Image)
	{
		if(!m_pImage)
		{
			c->error(__tr2qs_ctx("The pixmap is null", "objects"));
			return false;
		}
		*m_pImage = m_pImage->scaled(iWidth, iHeight, ratio, Qt::SmoothTransformation);
	}
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, loadAnimation)
{
	QString szFile;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("file", KVS_PT_STRING, 0, szFile)
	KVSO_PARAMETERS_END(c)

	if(!QFile::exists(szFile))
	{
		c->warning(__tr2qs_ctx("I can't find the specified file '%Q'.", "objects"), &szFile);
		return true;
	}
	if(m_pAnimatedPixmap)
	{
		delete m_pAnimatedPixmap;
		m_pAnimatedPixmap = nullptr;
	}
	if(m_pPixmap)
	{
		delete m_pPixmap;
		m_pPixmap = nullptr;
	}
	m_pAnimatedPixmap = new KviAnimatedPixmap(szFile);
	connect(m_pAnimatedPixmap, SIGNAL(frameChanged()), this, SLOT(frameChanged()));
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, startAnimation)
{
	if(m_pAnimatedPixmap)
		m_pAnimatedPixmap->start();
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, stopAnimation)
{
	if(m_pAnimatedPixmap)
		m_pAnimatedPixmap->stop();
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, load)
{
	QString szFile;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("file", KVS_PT_STRING, 0, szFile)
	KVSO_PARAMETERS_END(c)

	if(!QFile::exists(szFile))
	{
		c->warning(__tr2qs_ctx("I can't find the specified file '%Q'.", "objects"), &szFile);
		return true;
	}
	if(!m_pImage)
		m_pImage = new QImage();
	m_currentType = Image;
	m_pImage->load(szFile);
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, save)
{
	QString szFile;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("file", KVS_PT_STRING, 0, szFile)
	KVSO_PARAMETERS_END(c)

	if(m_currentType == Pixmap)
	{
		if(m_pPixmap)
		{
			m_pPixmap->save(szFile);
		}
		else
		{
			c->error(__tr2qs_ctx("The pixmap is null", "objects"));
			return false;
		}
	}
	else if(m_currentType == Image)
	{
		if(m_pImage)
		{
			m_pImage->save(szFile);
		}
		else
		{
			c->error(__tr2qs_ctx("The pixmap is null", "objects"));
			return false;
		}
	}
	else
	{
		m_pAnimatedPixmap->pixmap()->save(szFile);
	}
	return true;
}

void KvsObject_pixmap::setInternalPixmap(QPixmap * pPixmap)
{
	if(m_currentType == Image && m_pImage)
		delete m_pImage;
	else if(m_currentType == Pixmap && m_pPixmap)
		delete m_pPixmap;
	m_currentType = Pixmap;
	m_pPixmap = pPixmap;
}
void KvsObject_pixmap::setInternalImage(QImage * pImage)
{
	if(m_currentType == Image && m_pImage)
		delete m_pImage;
	else if(m_currentType == Pixmap && m_pPixmap)
		delete m_pPixmap;
	m_currentType = Image;
	m_pImage = pImage;
}
KVSO_CLASS_FUNCTION(pixmap, loadFromMemoryBuffer)
{
	KviKvsObject * pObject;
	kvs_hobject_t hObject;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("hobject", KVS_PT_HOBJECT, 0, hObject)
	KVSO_PARAMETERS_END(c)

	pObject = KviKvsKernel::instance()->objectController()->lookupObject(hObject);
	if(!pObject)
	{
		c->warning(__tr2qs_ctx("Buffer parameter is not an object", "objects"));
		return true;
	}
	if(!pObject->inheritsClass("memorybuffer"))
	{
		c->warning(__tr2qs_ctx("Buffer parameter is not a memorybuffer object", "objects"));
		return true;
	}
	if(m_pAnimatedPixmap)
	{
		delete m_pAnimatedPixmap;
		m_pAnimatedPixmap = nullptr;
	}
	if(!m_pPixmap)
		m_pPixmap = new QPixmap();
	m_pPixmap->loadFromData(((KvsObject_memoryBuffer *)pObject)->dataBuffer());
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, grabWidget)
{
	CHECK_INTERNAL_POINTER(m_pPixmap)
	KviKvsObject * pObject;
	kvs_hobject_t hObject;
	KVSO_PARAMETERS_BEGIN(c)
	KVSO_PARAMETER("widget", KVS_PT_HOBJECT, 0, hObject)
	KVSO_PARAMETERS_END(c)

	pObject = KviKvsKernel::instance()->objectController()->lookupObject(hObject);
	CHECK_HOBJECT_IS_WIDGET(pObject)
	if(m_pAnimatedPixmap)
	{
		delete m_pAnimatedPixmap;
		m_pAnimatedPixmap = nullptr;
	}
	if(!m_pPixmap)
		m_pPixmap = new QPixmap();
	*m_pPixmap = ((KvsObject_widget *)pObject)->widget()->grab();
	return true;

}

KVSO_CLASS_FUNCTION(pixmap, height)
{
	if(m_currentType == Image && m_pImage)
		c->returnValue()->setInteger(m_pImage->height());
	else if(m_currentType == Pixmap && m_pPixmap)
		c->returnValue()->setInteger(m_pPixmap->height());
	else
		c->returnValue()->setInteger(0);
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, width)
{
	if(m_currentType == Image && m_pImage)
		c->returnValue()->setInteger(m_pImage->width());
	else if(m_currentType == Pixmap && m_pPixmap)
		c->returnValue()->setInteger(m_pPixmap->width());
	else
		c->returnValue()->setInteger(0);
	return true;
}

KVSO_CLASS_FUNCTION(pixmap, frameChangedEvent)
{
	emitSignal("frameChanged", c);
	return true;
}

// slots
void KvsObject_pixmap::frameChanged()
{
	KviKvsVariantList * params = nullptr;
	callFunction(this, "frameChangedEvent", params);
}
