/**********************************************************************
** Copyright (C) 2000 Trolltech AS.  All rights reserved.
**
** This file is part of Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "canvascard.h"

#include <opie2/oresource.h>

#include <qgfx_qws.h> // Needed to get the device's width

#include <math.h>

#if defined( QT_QWS_CASSIOPEIA )
#define SLOW_HARDWARE
#endif

// Seems to be fast enough to me even without Transformations in the library
//#if defined( QT_NO_TRANSFORMATIONS ) && defined( QT_QWS_IPAQ )
//#define SLOW_HARDWARE
//#endif


QBitmap *Create180RotatedBitmap(QBitmap *srcBitmap)
{
#ifdef QT_NO_TRANSFORMATIONS
    int w = srcBitmap->width();
    int h = srcBitmap->height();
    QBitmap *dstBitmap = new QBitmap( w, h );
    // ### this is very poorly implemented and probably could be much faster
    for (int i = 0; i < w; i++)
	for (int j = 0; j < h; j++)
	    bitBlt( dstBitmap, i, j, srcBitmap, w - i - 1, h - j - 1, 1, 1 );
    return dstBitmap;
#else
    QWMatrix m;
    m.rotate( 180.0 );
    return new QBitmap( srcBitmap->xForm( m ) );
#endif
}


QPixmap *CreateScaledPixmap(QPixmap *srcPixmap, double scaleX, double scaleY)
{
#ifdef QT_NO_TRANSFORMATIONS
    int w = srcPixmap->width();
    int h = srcPixmap->height();
    int newW = (int)(w * scaleX);
    int newH = (int)(h * scaleY);
    QPixmap *dstPixmap = new QPixmap( newW, newH );
    // ### this is very poorly implemented and probably could be much faster
    for (int i = 0; i < newW; i++) {
	int srcX = w * i / newW;
	if (newH == h) {
	    // Optimise for scaleing in the X-axis only
	    bitBlt( dstPixmap, i, 0, srcPixmap, srcX, 0, 1, h );
	} else {
	    for (int j = 0; j < newH; j++) {
		int srcY = h * j / newH;
		bitBlt( dstPixmap, i, j, srcPixmap, srcX, srcY, 1, 1 );
	    }
        }
    }
    return dstPixmap;
#else
    QWMatrix s;
    s.scale( scaleX, scaleY );
    return new QPixmap( srcPixmap->xForm( s ) );
#endif
}


// Initialise static member variables to NULL
QPixmap *CanvasCard::cardsFaces = NULL;
QPixmap *CanvasCard::cardsBacks = NULL;
QBitmap *CanvasCard::cardsChars = NULL;
QBitmap *CanvasCard::cardsSuits = NULL;
QBitmap *CanvasCard::cardsCharsUpsideDown = NULL;
QBitmap *CanvasCard::cardsSuitsUpsideDown = NULL;


CanvasCard::CanvasCard( eValue v, eSuit s, bool f, QCanvas *canvas ) :
	Card(v, s, f), QCanvasRectangle( 0, 0, 1, 1, canvas ), cardBack(1), scaleX(1.0), scaleY(1.0)
{
    if ( !cardsFaces ) {
	if ( qt_screen->deviceWidth() < 200 ) {
	    cardsFaces = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_face_small" ) );
	    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0001_small" ) );
	    cardsChars = new QBitmap();
        *cardsChars = Opie::Core::OResource::loadPixmap( "cards/card_chars_small" );
	    cardsSuits = new QBitmap();
        *cardsSuits = Opie::Core::OResource::loadPixmap( "cards/card_suits_small" );
	} else {
	    cardsFaces = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_face" ) );
	    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0001" ) );
	    cardsChars = new QBitmap();
        *cardsChars = Opie::Core::OResource::loadPixmap( "cards/card_chars" );
	    cardsSuits = new QBitmap();
        *cardsSuits = Opie::Core::OResource::loadPixmap( "cards/card_suits" );
	}
	cardsCharsUpsideDown = Create180RotatedBitmap( cardsChars );
	cardsSuitsUpsideDown = Create180RotatedBitmap( cardsSuits );
    }
    xOff = cardsFaces->width() / 2;
    yOff = cardsFaces->height() / 2;
    setSize( cardsFaces->width(), cardsFaces->height() );
    setPen( NoPen );
    flipping = FALSE;
}


void CanvasCard::setCardBack(int b)
{
    if ( cardBack != b ) {

	cardBack = b;

	if ( cardsBacks )
	    delete cardsBacks;

	if ( qt_screen->deviceWidth() < 200 ) {
	    switch (cardBack) {
		case 0:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0001_small" ) ); break;
		case 1:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0002_small" ) ); break;
		case 2:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0003_small" ) ); break;
		case 3:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0004_small" ) ); break;
		case 4:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0005_small" ) ); break;
	    }
	} else {
	    switch (cardBack) {
		case 0:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0001" ) ); break;
		case 1:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0002" ) ); break;
		case 2:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0003" ) ); break;
		case 3:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0004" ) ); break;
		case 4:
		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0005" ) ); break;
	    }
	}

        if ( !isFacing() )
	    redraw();
    }
}


void CanvasCard::draw(QPainter &painter)
{
    int ix = (int)x(), iy = (int)y();

    QPainter *p = &painter;
    QPixmap *unscaledCard = NULL;

    if ((scaleX <= 0.98) || (scaleY <= 0.98)) 
    {
	p = new QPainter();
	unscaledCard = new QPixmap( cardsFaces->width(), cardsFaces->height() );
	p->begin(unscaledCard);
	ix = 0;
	iy = 0;
    }
	
    if ( isFacing() ) {
	
	int w = cardsFaces->width(), h = cardsFaces->height();

	p->setBrush( QColor( 0xFF, 0xFF, 0xFF ) );

	if ( isRed() == TRUE )
	    p->setPen( QColor( 0xFF, 0, 0 ) );
	else
	    p->setPen( QColor( 0, 0, 0 ) );

	if ( qt_screen->deviceWidth() < 200 ) {
	    p->drawPixmap( ix +      0, iy +     0, *cardsFaces );
	    p->drawPixmap( ix +      3, iy +     3, *cardsChars, 5*(getValue()-1), 0, 5, 6 );
	    p->drawPixmap( ix +     11, iy +     3, *cardsSuits, 5*(getSuit()-1), 0, 5, 6 );
	    p->drawPixmap( ix +  w-3-5, iy + h-3-6, *cardsCharsUpsideDown, 5*(12-getValue()+1), 0, 5, 6 );
	    p->drawPixmap( ix + w-11-5, iy + h-3-6, *cardsSuitsUpsideDown, 5*(3-getSuit()+1), 0, 5, 6 );
	} else {
	    p->drawPixmap( ix +      0, iy +     0, *cardsFaces );
	    p->drawPixmap( ix +      4, iy +     4, *cardsChars, 7*(getValue()-1), 0, 7, 7 );
	    p->drawPixmap( ix +     12, iy +     4, *cardsSuits, 7*(getSuit()-1), 0, 7, 8 );
	    p->drawPixmap( ix +  w-4-7, iy + h-4-7, *cardsCharsUpsideDown, 7*(12-getValue()+1), 0, 7, 7 );
	    p->drawPixmap( ix + w-12-7, iy + h-5-7, *cardsSuitsUpsideDown, 7*(3-getSuit()+1), 0, 7, 8 );
	}

    } else {
	
	p->drawPixmap( ix, iy, *cardsBacks );

    }

    if (p != &painter && unscaledCard)
    {
	p->end();
	QPixmap *scaledCard = CreateScaledPixmap( unscaledCard, scaleX, scaleY );
	int xoff = scaledCard->width() / 2;
	int yoff = scaledCard->height() / 2;
	painter.drawPixmap( (int)x() + xOff - xoff, (int)y() + yOff - yoff, *scaledCard );
	delete p;
	delete unscaledCard;
	delete scaledCard;
    }
}


static const double flipLift = 1.5;


void CanvasCard::flipTo(int x2, int y2, int steps)
{
    flipSteps = steps;

#ifdef SLOW_HARDWARE
    move(x2,y2);
    Card::flipTo(x2,y2,steps);
#else
    int x1 = (int)x();
    int y1 = (int)y();
    double dx = x2 - x1;
    double dy = y2 - y1;

    flipping = TRUE;
    destX = x2;
    destY = y2;
    animSteps = flipSteps;
    setVelocity(dx/animSteps, dy/animSteps-flipLift);
    setAnimated(TRUE);
#endif
}


void CanvasCard::advance(int stage)
{
    if ( stage==1 ) {
	if ( animSteps-- <= 0 ) {
	    scaleX = 1.0;
	    scaleY = 1.0;
	    flipping = FALSE;
	    setVelocity(0,0);
	    setAnimated(FALSE);
	    move(destX,destY); // exact
	} else {
	    if ( flipping ) {
		if ( animSteps > flipSteps / 2 ) {
		    // animSteps = flipSteps .. flipSteps/2 (flip up) -> 1..0
		    scaleX = ((double)animSteps/flipSteps-0.5)*2;
		} else {
		    // animSteps = flipSteps/2 .. 0 (flip down) -> 0..1
		    scaleX = 1-((double)animSteps/flipSteps)*2;
		}
		if ( animSteps == flipSteps / 2-1 ) {
		    setYVelocity(yVelocity()+flipLift*2);
		    setFace( !isFacing() );
		}
	    }
	}
    }
    QCanvasRectangle::advance(stage);
}


void CanvasCard::animatedMove(int x2, int y2, int steps)
{
    destX = x2;
    destY = y2;

    double x1 = x(), y1 = y(), dx = x2 - x1, dy = y2 - y1;

    // Ensure a good speed
    while ( fabs(dx/steps)+fabs(dy/steps) < 5.0 && steps > 4 )
	steps--;

    setAnimated(TRUE);
    setVelocity(dx/steps, dy/steps);

    animSteps = steps;
}