/***************************************************************************
 *   Copyright (C) 2004 by Johan Maes - ON4QZ                              *
 *   on4qz@telenet.be                                                      *
 *   http://users.telenet.be/on4qz                                         *
 *                                                                         *
 *   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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "canvasitems.h"
#include "effects.h"
#include <qfont.h>
#include <qfontmetrics.h>
#include <qdatetime.h>
#include "configdialog.h"

canvasItemBase::canvasItemBase(QCanvas *cnv):QCanvasRectangle(cnv),itemRect(0,0,1,1)
{
	final=FALSE;
	locked=FALSE;
	gradient=0;
	angle=0;shear=0.;
	font.setFamily("Helvetica");
}

void canvasItemBase::setParam(scanvasItemParam &param,int depth)
{
	setGeometry(param.rect.topLeft(),param.rect.bottomRight());
	text=param.text;
	fullImage=param.img;
	//debug("setting full image");
	setShear(param.shear);
	setRotate(param.angle);
	locked=param.locked;
	foreground=(param.foreground);
	background=(param.background);
	lineWidth=(param.lineWidth);
	font=param.font;
	gradient=param.gradient;
	setZ(depth);
}

void canvasItemBase::getParam(scanvasItemParam &param)
{
	param.rect=itemRect;
	param.text=text;
	param.img=fullImage;
	param.shear=shear;
	param.angle=angle;
	param.locked=locked;
	param.type=rtti();
	param.foreground=foreground;
	param.background=background;
	param.lineWidth=lineWidth;
	param.font=font;
	param.gradient=gradient;
}

void canvasItemBase::setGeometry(QPoint start,QPoint end)
{
	negSlope=TRUE;
	if((( start.x()<=end.x())&&(start.y()<=end.y())) || (( start.x()>=end.x())&&(start.y()>=end.y())))
		{
			negSlope=FALSE;
		}
	itemRect.setTopLeft(start);
	itemRect.setBottomRight(end);
	if(itemRect.width()==0) itemRect.setWidth(1);
	if(itemRect.height()==0) itemRect.setHeight(1);
//			notNormalizedItemRect=itemRect;
	itemRect=itemRect.normalize();
	setX(itemRect.x());
	setY(itemRect.y());
	setSize(itemRect.width(),itemRect.height());
	updateActiveImage();
//	changed=TRUE;
}

void canvasItemBase::moveBy(int x,int y)
{
	itemRect.moveBy(x,y);
	QCanvasRectangle::moveBy(x,y);
}

void canvasItemBase::applyColors(QColor fg,QColor bg,int lW)
{
	foreground=fg;
	background=bg;
	lineWidth=lW;
	updateActiveImage();
}

void canvasItemBase::changeFont(QFont newFont)
{
	font=newFont;
	updateActiveImage();
}


		
void canvasItemBase::load(QDataStream &str)
{
	//debug("load");
	QColor fg;
	QColor bg;
	Q_UINT32 lw;
	QSize sz;
	Q_UINT32 z,bl;
	QPoint startP,endP;	
	str >> foreground;	
	str >> background;
	str >> lw; 
	lineWidth=lw;
	str >>startP; //startPoint
	str >>endP; // endPoint
	str >> z; //  depth
	str >> bl; // locked
	locked=bl;
	str >> gradient;
	str >> shear;
	str >> angle;
	setShear(shear);
	setRotate(angle);
	str >> text;
	str>>font;
	setZ(z);
	create(startP,endP);
	setVisible(TRUE);
	if(rtti()==imageRTTI)
		{
			str >> fullImage;
			setFinal(TRUE);
		}
	
}

void canvasItemBase::save(QDataStream &str)
{
	// save type
	str << (Q_INT16) rtti ();
	str << foreground;
	str << background;
	str << (Q_UINT32) lineWidth;
	str << startPoint() << endPoint();
	str << (Q_UINT32) z();
	str << (Q_UINT32)locked;
	str << (Q_UINT32) gradient;
	str << shear;
	str << angle;
	str << text;
	str <<font;
	if(rtti()==imageRTTI)
		{
			str << fullImage;
		}
}
void canvasItemBase::drawShape(QPainter &p)
{
	p.drawImage(itemRect.x(),itemRect.y(),activeImage);
	if(rtti()==imageRTTI)
		{
			//debug("image drawshape, final=%d",final);
		}
	if(isSelected())
		{
		// drawSelection(p,rect()); this does not scale
			QRect r((int)x(),(int)y(),size().width(),size().height());
			p.setPen(QPen(Qt::white,1,Qt::DashDotLine));
			p.setBrush(Qt::NoBrush);
			p.drawRect(r);
			p.setPen(QPen(Qt::black,1,Qt::DashDotLine));
			p.drawRect(QRect(r.x()+1,r.y()+1,r.width()-2,r.height()-2));
			p.setPen(QPen(Qt::white,2,Qt::SolidLine));
			p.setBrush(QBrush(Qt::black,Qt::SolidPattern));
	
			// 4 corners
			lt.setRect(r.left(),r.top(),5,5);
			rt.setRect(r.right()-5,r.top(),5,5);
			lb.setRect(r.left(),r.bottom()-5,5,5);
			rb.setRect(r.right()-5,r.bottom()-5,5,5);
	
			int x=r.left()+r.width()/2 ;
			int y=r.top()+r.height()/2;
	
			mt.setRect(x-2,r.top(),5,5);
			mb.setRect(x-2,r.bottom()-5,5,5);
			lc.setRect(r.left(),y-2,5,5);
			rc.setRect(r.right()-5,y-2,5,5);
			if(locked) return;
			
			p.drawRect(lt);
			p.drawRect(rt);
			p.drawRect(lb);
			p.drawRect(rb);
	
			// 4 mid-points
	
			p.drawRect(mt);
			p.drawRect(mb);
			p.drawRect(lc);
			p.drawRect(rc);
			
			
		}
	
//	update();
}






eSizing canvasItemBase::checkGrip(QPoint cp)
{
	if (lt.contains(cp)) return SLT;
	if (rt.contains(cp)) return SRT;
	if (lb.contains(cp)) return SLB;
	if (rb.contains(cp)) return SRB;
	if (mt.contains(cp)) return SMT;
	if (mb.contains(cp)) return SMB;
	if (lc.contains(cp)) return SLC;
	if (rc.contains(cp)) return SRC;
	return SMOVE;
}


void canvasItemBase::scaleImage()
{
	activeImage=fullImage.smoothScale(itemRect.size());
}


void canvasItemBase::pixmapToActiveImage(QPixmap &pm)
{
	int i,j;
	//debug("convertPixmap");
	activeImage=pm;
	for(j=0;j<itemRect.height();j++)
		{
			QRgb *pp=(QRgb *)activeImage.scanLine(j);
			for(i=0;i<itemRect.width();i++)
				{
					if((pp[i]&0x00ffffff)==0) pp[i]=0;
					else if ((pp[i]&0x0000ff)!=0)
						{
							pp[i]=foreground.rgb();
						}
					else pp[i]=background.rgb();
				}
		}
	activeImage.setAlphaBuffer(TRUE);
	if (gradient==1)
		{
			horizontalGradient(activeImage,foreground,background);
		}
	else if (gradient==2)
		{
			verticalGradient(activeImage,foreground,background);
		}
	activeImage.setAlphaBuffer(FALSE);
	activeImage=activeImage.xForm(mtx);
	activeImage.setAlphaBuffer(TRUE);
	setSize(activeImage.width(),activeImage.height());
}

/*
void canvasItemBase::convertPixmap(QPainter &p)
{
	int i,j;
	//debug("convertPixmap");
	if(changed)
		{
			activeImage=pm;
			for(j=0;j<itemRect.height();j++)
				{
					QRgb *pp=(QRgb *)activeImage.scanLine(j);
					for(i=0;i<itemRect.width();i++)
						{
							if((pp[i]&0x00ffffff)==0) pp[i]=0;
							else if ((pp[i]&0x0000ff)!=0)
								{
									pp[i]=foreground.rgb();
								}
							else pp[i]=background.rgb();
						}
				}
			activeImage.setAlphaBuffer(TRUE);
			if (gradient==1)
				{
					horizontalGradient(activeImage,foreground,background);
				}
			else if (gradient==2)
				{
					verticalGradient(activeImage,foreground,background);
				}
			activeImage.setAlphaBuffer(FALSE);
			activeImage=activeImage.xForm(mtx);
			activeImage.setAlphaBuffer(TRUE);
			//activeImage=activeImage.smoothScale(itemRect.size());
			setSize(activeImage.width(),activeImage.height());
		}
	p.drawImage(itemRect.x(),itemRect.y(),activeImage);
	changed=FALSE;
}*/


rectangle::rectangle(QCanvas *cnv):canvasItemBase(cnv)
{
}

rectangle::~rectangle()
{
}


void rectangle::create(QPoint start,QPoint end)
{
	//debug("creating rect");
	setGeometry(start,end);
	setVisible(TRUE);
	update();
}

void rectangle::updateActiveImage()
{
	QPixmap pm;
	activeImage.create(itemRect.size(),32);
	pm.resize(itemRect.width(),itemRect.height());
	//debug("w=%d,y=%d,rectw=%d,recth=%d",itemRect.x(),itemRect.y(),itemRect.width(),itemRect.height());
	QPainter local(&pm);
	pm.fill(QRgb(0));
	//debug("penwidth=%d",pen().width());
	local.setPen(QPen(QRgb(FGC),lineWidth));
	local.setBrush(QBrush(QRgb(BGC),QBrush::SolidPattern));
	local.drawRect(lineWidth/2,lineWidth/2,itemRect.width()-lineWidth+1,itemRect.height()-lineWidth+1);
	pixmapToActiveImage(pm);
}
			

imageItem::imageItem( QImage img, QCanvas *canvas ) : canvasItemBase( canvas )
{
	fullImage=img.copy();
}

imageItem::imageItem(QCanvas *canvas ) : canvasItemBase( canvas )
{
}

void imageItem::create(QPoint start,QPoint end)
{
	// debug("creating image");
	setGeometry(start,end);
	setVisible(TRUE);
	update();
	final=FALSE;
}

void imageItem::updateActiveImage()
{
	QPixmap pm;
	if(!final)
		{
			//activeImage.create(itemRect.size(),32);
			pm.resize(itemRect.width(),itemRect.height());
			QPainter local(&pm);
			pm.fill(QRgb(0));
			local.setPen(QPen(QRgb(FGC),1));
			local.setBrush(QBrush(QRgb(BGC),QBrush::SolidPattern));
			local.drawRect(0,0,itemRect.width(),itemRect.height());
			pixmapToActiveImage(pm);
			//debug("drawing non-final image");
		}
	else 
		{
			
			scaleImage();
			activeImage.setAlphaBuffer(FALSE);
			activeImage=activeImage.xForm(mtx);
			activeImage.setAlphaBuffer(TRUE);
			setSize(activeImage.width(),activeImage.height());
			//debug("drawing final image");
		}
}

textItem::textItem(QCanvas *cnv):canvasItemBase( cnv )
{
}

textItem::~textItem()
{
}

void textItem::create(QPoint start,QPoint end)
{
	//debug("creating text");
	setGeometry(start,end);
	setVisible(TRUE);
	update();
}

void textItem::updateActiveImage()
{
	QPainter local;
	QPixmap pm;
//	debug("creating text.%s",(const char *)text);
	convertText();
	pm.resize(itemRect.width(),itemRect.height());
	pm.fill(QRgb(0));
	local.begin( &pm );
	local.setPen(QPen(QRgb(FGC),lineWidth));
	local.setBrush(QBrush(QRgb(BGC),QBrush::SolidPattern));
//			int textYPos = 0; // distance from boundingRect y pos to baseline
//    	int textXPos = 0; // distance from boundingRect x pos to text start 
    	
	local.setFont( font );
	local.drawText( 0,0,itemRect.width(),itemRect.height(),Qt::AlignCenter,convertedText );
	local.end();
	pixmapToActiveImage(pm);
}

void textItem::convertText()
{
	unsigned int i;
	convertedText="";
	bool special=FALSE;
	char c;
	QDateTime t;

	for (i=0;i<text.length();i++)
		{
			if (special)
				{
					special=FALSE;
					c=text.at(i).latin1();
					switch(c)
						{
							case '%':
							convertedText.append('%');
							break;
							case 't':
								convertedText.append(t.currentDateTime(Qt::UTC).toString("hh:mm"));
							break;
							case 'd':
								convertedText.append(t.currentDateTime(Qt::UTC).toString("yyyy/MM/dd"));
							break;
							case 'm':
							convertedText.append(callsign);
							break;
							case 'c':
							convertedText.append(toCall);
							break;
							case 'r':
							convertedText.append(rst);
							break;
							case 'q':
							convertedText.append(qth);
							break;
							case 'l':
							convertedText.append(locator);
							break;
							case 'n':
							convertedText.append(lastname);
							break;
							case 'f':
							convertedText.append(firstname);
							break;
							case 'v':
							convertedText.append(qsstv_version);
							break;
							case 'o':
							convertedText.append(toOperator);
							break;
						}
					}
			else
				{
					if(text.at(i)!='%') convertedText.append(text.at(i));
					else special=TRUE;
				}
		}
	//debug(" converted text %s",(const char *) convertedText);
}

ellipse::ellipse(QCanvas *cnv):canvasItemBase( cnv )
{
}

ellipse::~ellipse()
{
}

void ellipse::create(QPoint start,QPoint end)
{
	// debug("creating ellipse");
	setGeometry(start,end);
	setVisible(TRUE);
	update();
}


void ellipse::updateActiveImage()
{
	QPixmap pm;
	pm.resize(itemRect.width(),itemRect.height());
	QPainter local(&pm);
	pm.fill(QRgb(0));
	local.setPen(QPen(QRgb(FGC),lineWidth));
	local.setBrush(QBrush(QRgb(BGC),QBrush::SolidPattern));
	local.drawEllipse(lineWidth/2,lineWidth/2,itemRect.width()-lineWidth,itemRect.height()-lineWidth);
	pixmapToActiveImage(pm);
}

line::line(QCanvas *cnv):canvasItemBase( cnv )
{
}

line::~line()
{
}

void line::create(QPoint start,QPoint end)
{
//	debug("creating line");
	setGeometry(start,end);
	setVisible(TRUE);
	update();
	
}


void line::updateActiveImage()
{
	QPixmap pm;
	pm.resize(itemRect.width(),itemRect.height());
	QPainter local(&pm);
	pm.fill(QRgb(0));
	local.setPen(QPen(QRgb(FGC),lineWidth));
	local.setBrush(QBrush(QRgb(BGC),QBrush::SolidPattern));
	if(!negSlope)
		{
			local.drawLine(0,0,itemRect.width()-1,itemRect.height()-1);
		}
	else
		{
			local.drawLine(itemRect.width()-1,0,0,itemRect.height()-1);
		}
	pixmapToActiveImage(pm);
}