You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
426 lines
11 KiB
426 lines
11 KiB
/*
|
|
Copyright (C) 2001-2003 KSVG Team
|
|
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
|
|
aint 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 "LibartCanvas.h"
|
|
#include "SVGMatrixImpl.h"
|
|
#include "SVGRectImpl.h"
|
|
#include "SVGPaintImpl.h"
|
|
#include "SVGShapeImpl.h"
|
|
#include "SVGDocumentImpl.h"
|
|
#include "SVGSVGElementImpl.h"
|
|
#include "SVGStringListImpl.h"
|
|
#include "SVGPatternElementImpl.h"
|
|
#include "SVGGradientElementImpl.h"
|
|
#include "SVGLinearGradientElementImpl.h"
|
|
#include "SVGRadialGradientElementImpl.h"
|
|
#include "SVGClipPathElementImpl.h"
|
|
#include "SVGTextPositioningElementImpl.h"
|
|
#include "SVGAnimatedLengthImpl.h"
|
|
#include "SVGAnimatedLengthListImpl.h"
|
|
#include "SVGAnimatedEnumerationImpl.h"
|
|
#include "SVGMarkerElementImpl.h"
|
|
#include "SVGMaskElementImpl.h"
|
|
|
|
#include <kdebug.h>
|
|
#include <tdeglobal.h>
|
|
#include <kgenericfactory.h>
|
|
|
|
#include "SVGPaint.h"
|
|
|
|
#include <tqdatetime.h>
|
|
#include <tqstring.h>
|
|
#include <tqimage.h>
|
|
|
|
#include "KSVGHelper.h"
|
|
#include "KSVGTextChunk.h"
|
|
#include "LibartCanvasItems.h"
|
|
|
|
#include <libart_lgpl/art_rgb.h>
|
|
#include <libart_lgpl/art_affine.h>
|
|
#include <libart_lgpl/art_alphagamma.h>
|
|
#include <libart_lgpl/art_rgb_svp.h>
|
|
#include <libart_lgpl/art_svp.h>
|
|
#include <libart_lgpl/art_svp_ops.h>
|
|
#include <libart_lgpl/art_svp_intersect.h>
|
|
#include <libart_lgpl/art_rect_svp.h>
|
|
#include <libart_lgpl/art_svp_vpath.h>
|
|
|
|
#include <libs/art_support/art_misc.h>
|
|
#include <libs/art_support/art_rgba_svp.h>
|
|
|
|
#include <Font.h>
|
|
#include "BezierPathLibart.h"
|
|
#include "GlyphTracerLibart.h"
|
|
|
|
#include <fontconfig/fontconfig.h>
|
|
|
|
ArtSVP *art_svp_from_rect(int x0, int y0, int x1, int y1)
|
|
{
|
|
ArtVpath vpath[] =
|
|
{
|
|
{ ART_MOVETO, (double)x0, (double)y0 },
|
|
{ ART_LINETO, (double)x0, (double)y1 },
|
|
{ ART_LINETO, (double)x1, (double)y1 },
|
|
{ ART_LINETO, (double)x1, (double)y0 },
|
|
{ ART_LINETO, (double)x0, (double)y0 },
|
|
{ ART_END, 0, 0}
|
|
};
|
|
|
|
return art_svp_from_vpath(vpath);
|
|
}
|
|
|
|
ArtSVP *art_svp_from_irect(ArtIRect *bbox)
|
|
{
|
|
return art_svp_from_rect(bbox->x0, bbox->y0, bbox->x1, bbox->y1);
|
|
}
|
|
|
|
ArtSVP *art_svp_from_qrect(const TQRect& rect)
|
|
{
|
|
return art_svp_from_rect(rect.left(), rect.top(), rect.right() + 1, rect.bottom() + 1);
|
|
}
|
|
|
|
using namespace KSVG;
|
|
|
|
LibartCanvas::LibartCanvas(unsigned int width, unsigned int height) : KSVGCanvas(width, height)
|
|
{
|
|
m_fontContext = new T2P::Converter(new T2P::GlyphTracerLibart());
|
|
}
|
|
|
|
T2P::BezierPath *LibartCanvas::toBezierPath(CanvasItem *item) const
|
|
{
|
|
LibartPath *path = dynamic_cast<LibartPath *>(item);
|
|
if(!path)
|
|
return 0;
|
|
|
|
// Only handle LibartPath items
|
|
//T2P::BezierPathLibart *result = new T2P::BezierPathLibart(path->m_array.data());
|
|
return path;
|
|
}
|
|
|
|
// drawing primitives
|
|
CanvasItem *LibartCanvas::createRectangle(SVGRectElementImpl *rect)
|
|
{
|
|
return new LibartRectangle(this, rect);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createEllipse(SVGEllipseElementImpl *ellipse)
|
|
{
|
|
return new LibartEllipse(this, ellipse);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createCircle(SVGCircleElementImpl *circle)
|
|
{
|
|
return new LibartCircle(this, circle);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createLine(SVGLineElementImpl *line)
|
|
{
|
|
return new LibartLine(this, line);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createPolyline(SVGPolylineElementImpl *poly)
|
|
{
|
|
return new LibartPolyline(this, poly);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createPolygon(SVGPolygonElementImpl *poly)
|
|
{
|
|
return new LibartPolygon(this, poly);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createPath(SVGPathElementImpl *path)
|
|
{
|
|
return new LibartPath(this, path);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createClipPath(SVGClipPathElementImpl *clippath)
|
|
{
|
|
CanvasClipPath *result = new LibartClipPath(this, clippath);
|
|
TQString index = clippath->id().string();
|
|
m_clipPaths.insert(index, result);
|
|
return result;
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createImage(SVGImageElementImpl *image)
|
|
{
|
|
return new LibartImage(this, image);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createCanvasMarker(SVGMarkerElementImpl *marker)
|
|
{
|
|
return new LibartMarker(this, marker);
|
|
}
|
|
|
|
CanvasItem *LibartCanvas::createText(SVGTextElementImpl *text)
|
|
{
|
|
return new LibartText(this, text);
|
|
}
|
|
|
|
CanvasPaintServer *LibartCanvas::createPaintServer(SVGElementImpl *pserver)
|
|
{
|
|
LibartPaintServer *result;
|
|
if(dynamic_cast<SVGLinearGradientElementImpl *>(pserver))
|
|
result = new LibartLinearGradient(dynamic_cast<SVGLinearGradientElementImpl *>(pserver));
|
|
else if(dynamic_cast<SVGRadialGradientElementImpl *>(pserver))
|
|
result = new LibartRadialGradient(dynamic_cast<SVGRadialGradientElementImpl *>(pserver));
|
|
else if(dynamic_cast<SVGPatternElementImpl *>(pserver))
|
|
result = new LibartPattern(dynamic_cast<SVGPatternElementImpl *>(pserver));
|
|
return result;
|
|
}
|
|
|
|
void LibartCanvas::drawImage(TQImage image, SVGStylableImpl *style, const SVGMatrixImpl *matrix, const KSVGPolygon& clippingPolygon)
|
|
{
|
|
SVGShapeImpl *shape = dynamic_cast<SVGShapeImpl *>(style);
|
|
|
|
if(shape)
|
|
{
|
|
if(image.depth() != 32)
|
|
image = image.convertDepth(32);
|
|
|
|
ArtSVP *imageBorder = svpFromPolygon(clippingPolygon);
|
|
ArtSVP *clipSvp = clipSingleSVP(imageBorder, shape);
|
|
|
|
ArtDRect bbox;
|
|
art_drect_svp(&bbox, clipSvp);
|
|
|
|
// clamp to viewport
|
|
int x0 = int(bbox.x0);
|
|
int y0 = int(bbox.y0);
|
|
|
|
// Use inclusive coords for x1/y1 for clipToBuffer
|
|
int x1 = int(ceil(bbox.x1)) - 1;
|
|
int y1 = int(ceil(bbox.y1)) - 1;
|
|
|
|
if(x0 < int(m_width) && y0 < int(m_height) && x1 >= 0 && y1 >= 0)
|
|
{
|
|
clipToBuffer(x0, y0, x1, y1);
|
|
|
|
TQRect screenBBox(x0, y0, x1 - x0 + 1, y1 - y0 + 1);
|
|
|
|
TQByteArray mask = SVGMaskElementImpl::maskRectangle(shape, screenBBox);
|
|
|
|
double affine[6];
|
|
KSVGHelper::matrixToAffine(matrix, affine);
|
|
|
|
ksvg_art_rgb_affine_clip(clipSvp, m_buffer + x0 * nrChannels() + y0 * rowStride(), x0, y0, x1 + 1, y1 + 1, rowStride(), nrChannels(), image.bits(), image.width(), image.height(), image.width() * 4, affine, int(style->getOpacity() * 255), (const art_u8 *)mask.data());
|
|
}
|
|
|
|
art_svp_free(imageBorder);
|
|
art_svp_free(clipSvp);
|
|
}
|
|
}
|
|
|
|
ArtSVP *LibartCanvas::clippingRect(const TQRect &rect, const SVGMatrixImpl *ctm)
|
|
{
|
|
ArtVpath *vec = allocVPath(6);
|
|
// Order of points in clipping rectangle must be counter-clockwise
|
|
bool flip = ((ctm->a() * ctm->d()) < (ctm->b() * ctm->c()));
|
|
|
|
vec[0].code = ART_MOVETO;
|
|
vec[0].x = rect.x();
|
|
vec[0].y = rect.y();
|
|
|
|
vec[1].code = ART_LINETO;
|
|
vec[1].x = rect.x() + (flip ? rect.width() : 0);
|
|
vec[1].y = rect.y() + (flip ? 0 : rect.height());
|
|
|
|
vec[2].code = ART_LINETO;
|
|
vec[2].x = rect.x() + rect.width();
|
|
vec[2].y = rect.y() + rect.height();
|
|
|
|
vec[3].code = ART_LINETO;
|
|
vec[3].x = rect.x() + (flip ? 0 : rect.width());
|
|
vec[3].y = rect.y() + (flip ? rect.height() : 0);
|
|
|
|
vec[4].code = ART_LINETO;
|
|
vec[4].x = rect.x();
|
|
vec[4].y = rect.y();
|
|
|
|
vec[5].code = ART_END;
|
|
|
|
double affine[6];
|
|
KSVGHelper::matrixToAffine(ctm, affine);
|
|
|
|
ArtVpath *temp = art_vpath_affine_transform(vec, affine);
|
|
art_free(vec);
|
|
|
|
ArtSVP *result = art_svp_from_vpath(temp);
|
|
art_free(temp);
|
|
return result;
|
|
}
|
|
|
|
ArtSVP *LibartCanvas::clipSingleSVP(ArtSVP *svp, SVGShapeImpl *shape)
|
|
{
|
|
ArtSVP *clippedSvp = copy_svp(svp);
|
|
SVGStylableImpl *style = dynamic_cast<SVGStylableImpl *>(shape);
|
|
|
|
if(style)
|
|
{
|
|
TQString clipPathRef = style->getClipPath();
|
|
|
|
if(!clipPathRef.isEmpty())
|
|
{
|
|
CanvasClipPath *clipPath = m_clipPaths[clipPathRef];
|
|
|
|
if(clipPath)
|
|
{
|
|
LibartClipPath *lclip = dynamic_cast<LibartClipPath *>(clipPath);
|
|
reinterpret_cast<SVGClipPathElementImpl *>(clipPath->element())->setBBoxTarget(shape);
|
|
|
|
lclip->init();
|
|
|
|
if(lclip->clipSVP())
|
|
{
|
|
ArtSVP *s = art_svp_intersect(lclip->clipSVP(), clippedSvp);
|
|
art_svp_free(clippedSvp);
|
|
clippedSvp = s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SVGSVGElementImpl *svg = dynamic_cast<SVGSVGElementImpl *>(shape);
|
|
|
|
// Clip outer svg, unless width and height not set
|
|
if(svg && (!svg->isRootElement() || !svg->getAttribute("width").isEmpty() || !svg->getAttribute("height").isEmpty()) && !svg->getOverflow())
|
|
{
|
|
ArtSVP *svgClip = clippingRect(svg->clip(), svg->screenCTM());
|
|
ArtSVP *s = art_svp_intersect(svgClip, clippedSvp);
|
|
art_svp_free(clippedSvp);
|
|
art_svp_free(svgClip);
|
|
clippedSvp = s;
|
|
}
|
|
|
|
if(dynamic_cast<SVGPatternElementImpl *>(shape) != 0)
|
|
{
|
|
// TODO: inherit clipping paths into tile space
|
|
}
|
|
else if(dynamic_cast<SVGMarkerElementImpl *>(shape) != 0)
|
|
{
|
|
SVGMarkerElementImpl *marker = static_cast<SVGMarkerElementImpl *>(shape);
|
|
|
|
if(!marker->clipShape().isEmpty())
|
|
{
|
|
ArtSVP *clipShape = svpFromPolygon(marker->clipShape());
|
|
ArtSVP *s = art_svp_intersect(clipShape, clippedSvp);
|
|
art_svp_free(clipShape);
|
|
art_svp_free(clippedSvp);
|
|
clippedSvp = s;
|
|
}
|
|
|
|
// TODO: inherit clipping paths into marker space
|
|
}
|
|
else
|
|
{
|
|
SVGElementImpl *element = dynamic_cast<SVGElementImpl *>(shape);
|
|
DOM::Node parentNode = element->parentNode();
|
|
|
|
if(!parentNode.isNull())
|
|
{
|
|
SVGElementImpl *parent = element->ownerDoc()->getElementFromHandle(parentNode.handle());
|
|
|
|
if(parent)
|
|
{
|
|
SVGShapeImpl *parentShape = dynamic_cast<SVGShapeImpl *>(parent);
|
|
|
|
if(parentShape)
|
|
{
|
|
// Clip against ancestor clipping paths
|
|
ArtSVP *parentClippedSvp = clipSingleSVP(clippedSvp, parentShape);
|
|
art_svp_free(clippedSvp);
|
|
clippedSvp = parentClippedSvp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return clippedSvp;
|
|
}
|
|
|
|
void LibartCanvas::drawSVP(ArtSVP *svp, art_u32 color, TQByteArray mask, TQRect screenBBox)
|
|
{
|
|
int x0 = screenBBox.left();
|
|
int y0 = screenBBox.top();
|
|
int x1 = screenBBox.right();
|
|
int y1 = screenBBox.bottom();
|
|
|
|
if(m_nrChannels == 3)
|
|
{
|
|
if(mask.data())
|
|
art_ksvg_rgb_svp_alpha_mask(svp, x0, y0, x1 + 1, y1 + 1, color, m_buffer + x0 * 3 + y0 * 3 * m_width, m_width * 3, 0, (art_u8 *)mask.data());
|
|
else
|
|
art_rgb_svp_alpha(svp, x0, y0, x1 + 1, y1 + 1, color, m_buffer + x0 * 3 + y0 * 3 * m_width, m_width * 3, 0);
|
|
}
|
|
else
|
|
art_ksvg_rgba_svp_alpha(svp, x0, y0, x1 + 1, y1 + 1, color, m_buffer + x0 * 4 + y0 * 4 * m_width, m_width * 4, 0, (art_u8 *)mask.data());
|
|
}
|
|
|
|
ArtSVP *LibartCanvas::copy_svp(const ArtSVP *svp)
|
|
{
|
|
// No API to copy an SVP so do so without accessing the data structure directly.
|
|
ArtVpath *vec = allocVPath(1);
|
|
|
|
vec[0].code = ART_END;
|
|
|
|
ArtSVP *empty = art_svp_from_vpath(vec);
|
|
art_free(vec);
|
|
|
|
ArtSVP *result = art_svp_union(empty, svp);
|
|
art_svp_free(empty);
|
|
|
|
return result;
|
|
}
|
|
|
|
ArtSVP *LibartCanvas::svpFromPolygon(const KSVGPolygon& polygon)
|
|
{
|
|
if(polygon.numPoints() > 2)
|
|
{
|
|
ArtVpath *points = new ArtVpath[polygon.numPoints() + 2];
|
|
|
|
points[0].code = ART_MOVETO;
|
|
points[0].x = polygon.point(0).x();
|
|
points[0].y = polygon.point(0).y();
|
|
|
|
unsigned int i;
|
|
|
|
for(i = 1; i < polygon.numPoints(); i++)
|
|
{
|
|
points[i].code = ART_LINETO;
|
|
points[i].x = polygon.point(i).x();
|
|
points[i].y = polygon.point(i).y();
|
|
}
|
|
|
|
points[i].code = ART_LINETO;
|
|
points[i].x = polygon.point(0).x();
|
|
points[i].y = polygon.point(0).y();
|
|
|
|
points[i + 1].code = ART_END;
|
|
|
|
ArtSVP *svp = art_svp_from_vpath(points);
|
|
delete [] points;
|
|
|
|
return svp;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
// vim:ts=4:noet
|