/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:    
*
*/

#ifndef HGQUADRENDERER_H
#define HGQUADRENDERER_H

#include <QList>
#include <QImage>
#include <QVector2D>

class HgQuad;
class QPointF;
class QPainter;
class QRectF;
class QMatrix4x4;
class QPolygonF;
class HgImage;

/**
 *
 * Abstract class to be inherited by differend quad renderer implementations.
 * One could for example implement this in OpenGL instead of OpenVG.
 */
class HgQuadRenderer
{
public:
    /**
     * Destructor.
     */
    virtual ~HgQuadRenderer();
    /**
     * Gets the quad at given index.
     * @return HgQuad-object at index.        
     */
    virtual HgQuad* quad(int index);
    /**
     * Gets the max amount of quads this renderer can draw.
     * @return max amount of quads.
     */
    virtual int quadCount() const;
    /**
     * Gets quads index at pointer position.
     * @param pointer position.
     * @return quad under the pointer position or -1 if nothing is there.
     */
    virtual HgQuad* getQuadAt(const QPointF& point) const = 0;

    /**
     * Rasterize 3D quads to 2D screen using painter or underlying Native graphics API.
     * This should be called inside Widgets draw method.
     * @param painter QPainter-object.
     * @param rect window rectangle.
     * @param viewMatrix view matrix
     * @param projectionMatrix projection matrix
     * @param orientation current screen orientation
     */
    virtual void drawQuads(QPainter* painter, const QRectF& rect, 
        const QMatrix4x4& viewMatrix, const QMatrix4x4& projectionMatrix, 
        const Qt::Orientation orientation, 
        const QTransform& sceneTransform)=0;
    
    /**
     * 
     */
    virtual bool getQuadTranformedPointsByUserData(QPolygonF& points, const QVariant& userData) const=0;
    
    /**
     * 
     */
    virtual void setMirroringPlaneY(qreal mirroringPlaneY);

    /**
     * 
     */
    virtual HgImage* createNativeImage()=0;
        
    /**
     * 
     */
    virtual QList<HgQuad*> getVisibleQuads(const QRectF& rect) const=0;
    
    /**
     * 
     */
    virtual void setDefaultImage(QImage defaultImage);

    /**
     * 
     */
    virtual void setTranslation(const QVector2D& translate);
    
    /**
     * 
     */
    virtual HgQuad* getQuadByUserData(const QVariant& userData) const;
    
    /**
     * 
     */
    virtual QImage getDefaultImage() const;
    
    /**
     * 
     */
    virtual void enableReflections(bool enabled);
    
    /**
     * 
     */
    virtual bool reflectionsEnabled() const;
    
protected:    
    HgQuadRenderer(int maxQuads);

    QList<HgQuad*> mQuads;
    qreal mMirroringPlaneY;
    QImage mDefaultImage;
    QVector2D mTranslation;
    bool mReflectionsEnabled;
};

#endif