/*
 *  This file is part of the KDE libraries
 *  Copyright (c) 2001 Michael Goffioul <tdeprint@swing.be>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License version 2 as published by the Free Software Foundation.
 *
 *  This library 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
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public License
 *  along with this library; see the file COPYING.LIB.  If not, write to
 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA 02110-1301, USA.
 **/

#include "marginpreview.h"

#include <tdelocale.h>
#include <kdebug.h>
#include <tqpainter.h>
#include <kcursor.h>

#define	A4_WIDTH	595
#define	A4_HEIGHT	842
#define	A4_TOP		36
#define	A4_BOTTOM	806
#define	A4_LEFT		18
#define	A4_RIGHT	577

#define	SCALE(d,z)	((int)(float(d)*z+0.5))
#define	UNSCALE(d,z)	((int)(float(d)/z+0.5))

static void draw3DPage(TQPainter *p, TQRect r)
{
	// draw white page
	p->fillRect(r,TQt::white);
	// draw 3D border
	p->setPen(TQt::black);
	p->moveTo(r.left(),r.bottom());
	p->lineTo(r.right(),r.bottom());
	p->lineTo(r.right(),r.top());
	p->setPen(TQt::darkGray);
	p->lineTo(r.left(),r.top());
	p->lineTo(r.left(),r.bottom());
	p->setPen(TQt::gray);
	p->moveTo(r.left()+1,r.bottom()-1);
	p->lineTo(r.right()-1,r.bottom()-1);
	p->lineTo(r.right()-1,r.top()+1);
}

MarginPreview::MarginPreview(TQWidget *parent, const char *name)
	: TQWidget(parent,name)
{
	width_ = A4_WIDTH;
	height_ = A4_HEIGHT;
	top_ = A4_TOP;
	bottom_ = A4_BOTTOM;
	left_ = A4_LEFT;
	right_ = A4_RIGHT;
	nopreview_ = false;

	box_ = rect();
	zoom_ = 1.0;
	state_ = Fixed;
	oldpos_ = -1;
	symetric_ = false;

	setMouseTracking(true);
}

MarginPreview::~MarginPreview()
{
}

void MarginPreview::setPageSize(float w, float h)
{
	setNoPreview(w <= 0 && h <= 0);
	// do not change relative margins when changing page size !!
	float	old_b(height_-bottom_), old_r(width_-right_);
	width_ = w;
	height_ = h;
	resizeEvent(NULL);
	setMargins(top_,old_b,left_,old_r);
	update();
}

void MarginPreview::setMargins(float t, float b, float l, float r)
{
	top_ = t;
	left_ = l;
	bottom_ = height_-b;
	right_ = width_-r;
	update();
}

void MarginPreview::setSymetric(bool on)
{
	symetric_ = on;
}

void MarginPreview::resizeEvent(TQResizeEvent *)
{
	if (width_/height_ > float(width())/height())
	{
		zoom_ = float(width()-3)/width_;
		box_.setLeft(1);
		box_.setRight(width()-3);
		int	m = (height()-3-SCALE(height_,zoom_))/2;
		box_.setTop(m+1);
		box_.setBottom(height()-m-3);
	}
	else
	{
		zoom_ = float(height()-3)/height_;
		box_.setTop(1);
		box_.setBottom(height()-3);
		int	m = (width()-3-SCALE(width_,zoom_))/2;
		box_.setLeft(m+1);
		box_.setRight(width()-m-3);
	}
}

void MarginPreview::paintEvent(TQPaintEvent *)
{
	TQPainter	p(this);

	TQRect	pagebox(TQPoint(box_.left()-1,box_.top()-1),TQPoint(box_.right()+2,box_.bottom()+2));

	if (nopreview_)
	{
		p.drawText(pagebox,AlignCenter,i18n("No preview available"));
	}
	else
	{
		draw3DPage(&p,pagebox);

		// draw margins
		p.setPen(DotLine);
		int	m = box_.left()+SCALE(left_,zoom_);
		margbox_.setLeft(m+1);
		p.drawLine(m,box_.top(),m,box_.bottom());
		m = box_.left()+SCALE(right_,zoom_);
		margbox_.setRight(m-1);
		p.drawLine(m,box_.top(),m,box_.bottom());
		m = box_.top()+SCALE(top_,zoom_);
		margbox_.setTop(m+1);
		p.drawLine(box_.left(),m,box_.right(),m);
		m = box_.top()+SCALE(bottom_,zoom_);
		margbox_.setBottom(m-1);
		p.drawLine(box_.left(),m,box_.right(),m);

		// fill useful area
		p.fillRect(margbox_,TQColor(220,220,220));
	}
}

void MarginPreview::setNoPreview(bool on)
{
	nopreview_ = on;
	update();
}

// 0: nothing
// 1: top
// 2: bottom
// 3: left
// 4: right
int MarginPreview::locateMouse(const TQPoint& p)
{
	int	tol = 2;
	if (p.x() <= margbox_.left()+tol && p.x() >= margbox_.left()-tol)
		return LMoving;
	else if (p.x() <= margbox_.right()+tol && p.x() >= margbox_.right()-tol)
		return RMoving;
	else if (p.y() <= margbox_.top()+tol && p.y() >= margbox_.top()-tol)
		return TMoving;
	else if (p.y() <= margbox_.bottom()+tol && p.y() >= margbox_.bottom()-tol)
		return BMoving;
	else
		return 0;
}

void MarginPreview::mouseMoveEvent(TQMouseEvent *e)
{
	if (nopreview_ || state_ == Fixed)
		return;
	int	pos = locateMouse(e->pos());
	if (state_ == None && e->button() == TQt::NoButton)
	{
		switch (pos)
		{
			case 1:
			case 2:
				setCursor(KCursor::sizeVerCursor());
				break;
			case 3:
			case 4:
				setCursor(KCursor::sizeHorCursor());
				break;
			default:
				setCursor(KCursor::arrowCursor());
				break;
		}
	}
	else if (state_ > None)
	{
		int newpos = -1;
		switch (state_)
		{
			case TMoving:
				newpos = TQMIN(TQMAX(e->pos().y(), box_.top()), (symetric_ ? (box_.top()+box_.bottom())/2 : margbox_.bottom()+1));
				break;
			case BMoving:
				newpos = TQMIN(TQMAX(e->pos().y(), (symetric_? (box_.top()+box_.bottom()+1)/2 : margbox_.top()-1)), box_.bottom());
				break;
			case LMoving:
				newpos = TQMIN(TQMAX(e->pos().x(), box_.left()), (symetric_ ? (box_.left()+box_.right())/2 : margbox_.right()+1));
				break;
			case RMoving:
				newpos = TQMIN(TQMAX(e->pos().x(), (symetric_ ? (box_.left()+box_.right()+1)/2 : margbox_.left()-1)), box_.right());
				break;
		}
		if (newpos != oldpos_)
		{
			TQPainter	p(this);
			p.setRasterOp(TQt::XorROP);
			p.setPen(gray);
			for (int i=0; i<2; i++, oldpos_ = newpos)
			{
				if (oldpos_ >= 0)
					drawTempLine(&p);
			}
		}
	}
}

void MarginPreview::drawTempLine(TQPainter *p)
{
	if (state_ >= LMoving)
	{
		p->drawLine(oldpos_, box_.top(), oldpos_, box_.bottom());
		if (symetric_)
		{
			int	mirror = box_.left()+box_.right()-oldpos_;
			p->drawLine(mirror, box_.top(), mirror, box_.bottom());
		}
	}
	else
	{
		p->drawLine(box_.left(), oldpos_, box_.right(), oldpos_);
		if (symetric_)
		{
			int	mirror = box_.top()+box_.bottom()-oldpos_;
			p->drawLine(box_.left(), mirror, box_.right(), mirror);
		}
	}
}

void MarginPreview::mousePressEvent(TQMouseEvent *e)
{
	if (e->button() != TQt::LeftButton || state_ != None)
		return;
	int	mpos = locateMouse(e->pos());
	if (mpos)
	{
		state_ = mpos;
	}
}

void MarginPreview::mouseReleaseEvent(TQMouseEvent *e)
{
	if (state_ > None)
	{
		TQPainter	p(this);
		p.setRasterOp(TQt::XorROP);
		p.setPen(gray);
		if (oldpos_ >= 0)
		{
			drawTempLine(&p);
			if (e)
			{
				float	val = 0;
				int st(state_);
				if (symetric_ && (st == BMoving || st == RMoving))
					st--;
				switch (st)
				{
					case TMoving:
						val = top_ = UNSCALE(oldpos_-box_.top(), zoom_);
						if (symetric_)
							bottom_ = height_-top_;
						break;
					case BMoving:
						bottom_ = UNSCALE(oldpos_-box_.top(), zoom_);
						val = UNSCALE(box_.bottom()-oldpos_, zoom_);
						break;
					case LMoving:
						val = left_ = UNSCALE(oldpos_-box_.left(), zoom_);
						if (symetric_)
							right_ = width_-left_;
						break;
					case RMoving:
						right_ = UNSCALE(oldpos_-box_.left(), zoom_);
						val = UNSCALE(box_.right()-oldpos_, zoom_);
						break;
				}
				update();
				emit marginChanged(st, val);
			}
		}
		state_ = 0;
		oldpos_ = -1;
	}
}

void MarginPreview::enableRubberBand(bool on)
{
	if (on && state_ == Fixed)
		state_ = None;
	else if (!on && state_ > Fixed)
	{
		mouseReleaseEvent(NULL);
		state_ = Fixed;
	}
}

#include "marginpreview.moc"
