/*
    Copyright (C) 2004, 2005 Nikolas Zimmermann <wildfox@kde.org>
                  2004, 2005 Rob Buis <buis@kde.org>

    This file is part of the KDE project

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    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., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
*/

#include "config.h"
#include <kdom/core/AttrImpl.h>

#include <kcanvas/KCanvas.h>
#include <kcanvas/KCanvasMatrix.h>
#include <kcanvas/KCanvasRegistry.h>
#include <kcanvas/KCanvasContainer.h>
#include <kcanvas/KCanvasCreator.h>
#include <kcanvas/KCanvasImage.h>
#include <kcanvas/device/KRenderingDevice.h>
#include <kcanvas/device/KRenderingPaintServerPattern.h>

#include "ksvg.h"
#include "svgattrs.h"
#include "SVGHelper.h"
#include "SVGMatrixImpl.h"
#include "SVGDocumentImpl.h"
#include "SVGSVGElementImpl.h"
#include "SVGTransformableImpl.h"
#include "SVGTransformListImpl.h"
#include "KCanvasRenderingStyle.h"
#include "SVGPatternElementImpl.h"
#include "SVGAnimatedStringImpl.h"
#include "SVGAnimatedLengthImpl.h"
#include "SVGDOMImplementationImpl.h"
#include "SVGAnimatedEnumerationImpl.h"
#include "SVGAnimatedTransformListImpl.h"

using namespace KSVG;

SVGPatternElementImpl::SVGPatternElementImpl(KDOM::DocumentPtr *doc, KDOM::NodeImpl::Id id, KDOM::DOMStringImpl *prefix) : SVGStyledElementImpl(doc, id, prefix), SVGURIReferenceImpl(), SVGTestsImpl(), SVGLangSpaceImpl(), SVGExternalResourcesRequiredImpl(), SVGFitToViewBoxImpl(), KCanvasResourceListener()
{
    m_patternUnits = 0;
    m_patternTransform = 0;
    m_patternContentUnits = 0;
    m_x = m_y = m_width = m_height = 0;

    m_tile = 0;
    m_paintServer = 0;
    m_ignoreAttributeChanges = false;
}

SVGPatternElementImpl::~SVGPatternElementImpl()
{
    if(m_x)
        m_x->deref();
    if(m_y)
        m_y->deref();
    if(m_width)
        m_width->deref();
    if(m_height)
        m_height->deref();
    if(m_patternUnits)
        m_patternUnits->deref();
    if(m_patternContentUnits)
        m_patternContentUnits->deref();
    if(m_patternTransform)
        m_patternTransform->deref();
    if (m_canvasItem)
        delete m_canvasItem;
}

SVGAnimatedEnumerationImpl *SVGPatternElementImpl::patternUnits() const
{
    if(!m_patternUnits)
    {
        lazy_create<SVGAnimatedEnumerationImpl>(m_patternUnits, this);
        m_patternUnits->setBaseVal(SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
    }

    return m_patternUnits;
}

SVGAnimatedEnumerationImpl *SVGPatternElementImpl::patternContentUnits() const
{
    if(!m_patternContentUnits)
    {
        lazy_create<SVGAnimatedEnumerationImpl>(m_patternContentUnits, this);
        m_patternContentUnits->setBaseVal(SVG_UNIT_TYPE_USERSPACEONUSE);
    }

    return m_patternContentUnits;
}

SVGAnimatedLengthImpl *SVGPatternElementImpl::x() const
{
    return lazy_create<SVGAnimatedLengthImpl>(m_x, this, LM_WIDTH, viewportElement());
}

SVGAnimatedLengthImpl *SVGPatternElementImpl::y() const
{
    return lazy_create<SVGAnimatedLengthImpl>(m_y, this, LM_HEIGHT, viewportElement());
}

SVGAnimatedLengthImpl *SVGPatternElementImpl::width() const
{
    return lazy_create<SVGAnimatedLengthImpl>(m_width, this, LM_WIDTH, viewportElement());
}

SVGAnimatedLengthImpl *SVGPatternElementImpl::height() const
{
    return lazy_create<SVGAnimatedLengthImpl>(m_height, this, LM_HEIGHT, viewportElement());
}

SVGAnimatedTransformListImpl *SVGPatternElementImpl::patternTransform() const
{
    return lazy_create<SVGAnimatedTransformListImpl>(m_patternTransform, this);
}

void SVGPatternElementImpl::parseAttribute(KDOM::AttributeImpl *attr)
{
    int id = (attr->id() & NodeImpl_IdLocalMask);
    KDOM::DOMString value(attr->value());
    switch(id)
    {
        case ATTR_PATTERNUNITS:
        {
            if(value == "userSpaceOnUse")
                patternUnits()->setBaseVal(SVG_UNIT_TYPE_USERSPACEONUSE);
            else if(value == "objectBoundingBox")
                patternUnits()->setBaseVal(SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
            break;
        }
        case ATTR_PATTERNCONTENTUNITS:
        {
            if(value == "userSpaceOnUse")
                patternContentUnits()->setBaseVal(SVG_UNIT_TYPE_USERSPACEONUSE);
            else if(value == "objectBoundingBox")
                patternContentUnits()->setBaseVal(SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
            break;
        }
        case ATTR_PATTERNTRANSFORM:
        {
            SVGTransformListImpl *patternTransforms = patternTransform()->baseVal();
            SVGTransformableImpl::parseTransformAttribute(patternTransforms, attr->value());
            break;
        }
        case ATTR_X:
        {
            x()->baseVal()->setValueAsString(value.handle());
            break;
        }
        case ATTR_Y:
        {
            y()->baseVal()->setValueAsString(value.handle());
            break;
        }
        case ATTR_WIDTH:
        {
            width()->baseVal()->setValueAsString(value.handle());
            break;
        }
        case ATTR_HEIGHT:
        {
            height()->baseVal()->setValueAsString(value.handle());
            break;
        }
        default:
        {
            if(SVGURIReferenceImpl::parseAttribute(attr)) return;
            if(SVGTestsImpl::parseAttribute(attr)) return;
            if(SVGLangSpaceImpl::parseAttribute(attr)) return;
            if(SVGExternalResourcesRequiredImpl::parseAttribute(attr)) return;
            if(SVGFitToViewBoxImpl::parseAttribute(attr)) return;

            SVGStyledElementImpl::parseAttribute(attr);
        }
    };
}

const SVGStyledElementImpl *SVGPatternElementImpl::pushAttributeContext(const SVGStyledElementImpl *context)
{
    // All attribute's contexts are equal (so just take the one from 'x').
    const SVGStyledElementImpl *restore = x()->baseVal()->context();

    x()->baseVal()->setContext(context);
    y()->baseVal()->setContext(context);
    width()->baseVal()->setContext(context);
    height()->baseVal()->setContext(context);

    return restore;
}

void SVGPatternElementImpl::resourceNotification() const
{
    // We're referenced by a "client", calculate the tile now...
    notifyAttributeChange();
}

void SVGPatternElementImpl::notifyAttributeChange() const
{
    if(!m_paintServer || !m_paintServer->activeClient())
        return;

    if(m_ignoreAttributeChanges)
        return;

    float w = width()->baseVal()->value();
    float h = height()->baseVal()->value();

    QSize newSize = QSize(qRound(w), qRound(h));
    if(m_tile && (m_tile->size() == newSize))
        return;

    m_ignoreAttributeChanges = true;

    // Find first pattern def that has children
    const KDOM::ElementImpl *target = this;

    const KDOM::NodeImpl *test = this;
    while(test && !test->hasChildNodes())
    {
        QString ref = KDOM::DOMString(href()->baseVal()).string();
        test = ownerDocument()->getElementById(KDOM::DOMString(ref.mid(1)).handle());
        if(test && test->id() == ID_PATTERN)
            target = static_cast<const KDOM::ElementImpl *>(test);
    }

    unsigned short savedPatternUnits = patternUnits()->baseVal();
    unsigned short savedPatternContentUnits = patternContentUnits()->baseVal();

    KRenderingPaintServer *refServer = 0;
    QString ref = KDOM::DOMString(href()->baseVal()).string();
    if(!ref.isEmpty())
    {
        SVGDocumentImpl *document = static_cast<SVGDocumentImpl *>(ownerDocument());
        KCanvas *canvas = (document ? document->canvas() : 0);
        Q_ASSERT(canvas != 0);
        
        refServer = canvas->registry()->getPaintServerById(ref.mid(1));
    }

    KCanvasMatrix patternTransformMatrix;
    if(patternTransform()->baseVal()->numberOfItems() > 0)
        patternTransformMatrix = KCanvasMatrix(patternTransform()->baseVal()->consolidate()->matrix()->qmatrix());

    if(refServer && refServer->type() == PS_PATTERN)
    {
        KRenderingPaintServerPattern *refPattern = static_cast<KRenderingPaintServerPattern *>(refServer);
        
        if(!hasAttribute(KDOM::DOMString("patternUnits").handle()))
        {
            KDOM::DOMString value(target->getAttribute(KDOM::DOMString("patternUnits").handle()));
            if(value == "userSpaceOnUse")
                patternUnits()->setBaseVal(SVG_UNIT_TYPE_USERSPACEONUSE);
            else if(value == "objectBoundingBox")
                patternUnits()->setBaseVal(SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
        }
        
        if(!hasAttribute(KDOM::DOMString("patternContentUnits").handle()))
        {
            KDOM::DOMString value(target->getAttribute(KDOM::DOMString("patternContentUnits").handle()));
            if(value == "userSpaceOnUse")
                patternContentUnits()->setBaseVal(SVG_UNIT_TYPE_USERSPACEONUSE);
            else if(value == "objectBoundingBox")
                patternContentUnits()->setBaseVal(SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
        }

        if(!hasAttribute(KDOM::DOMString("patternTransform").handle()))
            patternTransformMatrix = refPattern->patternTransform();
    }

    SVGStyledElementImpl *activeElement = static_cast<SVGStyledElementImpl *>(m_paintServer->activeClient()->userData());

    bool bbox = (patternUnits()->baseVal() == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);

    const SVGStyledElementImpl *savedContext = 0;
    if(bbox)
    {
        if(width()->baseVal()->unitType() != SVG_LENGTHTYPE_PERCENTAGE)
            width()->baseVal()->newValueSpecifiedUnits(SVG_LENGTHTYPE_PERCENTAGE, width()->baseVal()->value() * 100.);
        if(height()->baseVal()->unitType() != SVG_LENGTHTYPE_PERCENTAGE)
            height()->baseVal()->newValueSpecifiedUnits(SVG_LENGTHTYPE_PERCENTAGE, height()->baseVal()->value() * 100.);
        if(activeElement)
            savedContext = const_cast<SVGPatternElementImpl *>(this)->pushAttributeContext(activeElement);
    }    

    delete m_tile;
    m_tile = static_cast<KCanvasImage *>(canvas()->renderingDevice()->createResource(RS_IMAGE));
    m_tile->init(newSize);

    KRenderingDeviceContext *patternContext = canvas()->renderingDevice()->contextForImage(m_tile);
    canvas()->renderingDevice()->pushContext(patternContext);
//    KCanvasCommonArgs args;
//    args.setCanvas(canvas());
//    args.setStyle(item->style());
    
    KRenderingPaintServerPattern *pattern = static_cast<KRenderingPaintServerPattern *>(m_paintServer);
    pattern->setX(x()->baseVal()->value());
    pattern->setY(y()->baseVal()->value());
    pattern->setWidth(width()->baseVal()->value());
    pattern->setHeight(height()->baseVal()->value());
    pattern->setPatternTransform(patternTransformMatrix);
    pattern->setTile(m_tile);

    for(KDOM::NodeImpl *n = target->firstChild(); n != 0; n = n->nextSibling())
    {
        SVGStyledElementImpl *e = dynamic_cast<SVGStyledElementImpl *>(n);
        KCanvasItem *item = (e ? e->canvasItem() : 0);
        if(item && item->style())
        {
            KCanvasMatrix savedMatrix = item->style()->objectMatrix();

            const SVGStyledElementImpl *savedContext = 0;
            if(patternContentUnits()->baseVal() == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
            {
                if(activeElement)
                    savedContext = e->pushAttributeContext(activeElement);
            }

            // Take into account viewportElement's viewBox, if existant...
            if(viewportElement() && viewportElement()->id() == ID_SVG)
            {
                SVGSVGElementImpl *svgElement = static_cast<SVGSVGElementImpl *>(viewportElement());

                SVGMatrixImpl *svgCTM = svgElement->getCTM();
                svgCTM->ref();

                SVGMatrixImpl *ctm = SVGLocatableImpl::getCTM();
                ctm->ref();

                KCanvasMatrix newMatrix(svgCTM->qmatrix());
                newMatrix.multiply(savedMatrix);
                newMatrix.scale(1.0 / ctm->a(), 1.0 / ctm->d());

                item->style()->setObjectMatrix(newMatrix);

                ctm->deref();
                svgCTM->deref();
            }

            item->draw(QRect());

            if(savedContext)
                e->pushAttributeContext(savedContext);

            item->style()->setObjectMatrix(savedMatrix);
        }
    }

    if(savedContext)
        const_cast<SVGPatternElementImpl *>(this)->pushAttributeContext(savedContext);

    canvas()->renderingDevice()->popContext();
    delete patternContext;

    patternUnits()->setBaseVal(savedPatternUnits);
    patternContentUnits()->setBaseVal(savedPatternContentUnits);

    // Update all users of this resource...
    const KCanvasItemList &clients = pattern->clients();

    KCanvasItemList::ConstIterator it = clients.begin();
    KCanvasItemList::ConstIterator end = clients.end();

    for(; it != end; ++it)
    {
        const KCanvasItem *current = (*it);

        SVGStyledElementImpl *styled = (current ? static_cast<SVGStyledElementImpl *>(current->userData()) : 0);
        if(styled)
        {
            styled->setChanged(true);

            if(styled->canvasItem())
                styled->canvasItem()->invalidate();
        }
    }

    m_ignoreAttributeChanges = false;
}

KCanvasItem *SVGPatternElementImpl::createCanvasItem(KCanvas *canvas, KRenderingStyle *) const
{
    m_paintServer = canvas->renderingDevice()->createPaintServer(KCPaintServerType(PS_PATTERN));
    KRenderingPaintServerPattern *pserver = static_cast<KRenderingPaintServerPattern *>(m_paintServer);

    pserver->setListener(const_cast<SVGPatternElementImpl *>(this));

    canvas->registry()->addPaintServerById(KDOM::DOMString(getId()).string(), pserver);

    return 0;
}

SVGMatrixImpl *SVGPatternElementImpl::getCTM() const
{
    SVGMatrixImpl *mat = SVGSVGElementImpl::createSVGMatrix();
    if(mat)
    {
        SVGMatrixImpl *viewBox = viewBoxToViewTransform(width()->baseVal()->value(),
                                                        height()->baseVal()->value());

        viewBox->ref();
        mat->multiply(viewBox);
        viewBox->deref();
    }

    return mat;
}

// vim:ts=4:noet