String SVGViewSpec::viewBoxString() const
{
if (!viewBox())
return String();
return viewBox()->currentValue()->valueAsString();
}
AffineTransform RenderSVGContainer::viewportTransform() const
{
// FIXME: The method name is confusing, since it does not
// do viewport translating anymore. Look into this while
// fixing bug 12207.
if (!viewBox().isEmpty()) {
FloatRect viewportRect = viewport();
if (!parent()->isSVGContainer())
viewportRect = FloatRect(viewport().x(), viewport().y(), width(), height());
return getAspectRatio(viewBox(), viewportRect);
}
return AffineTransform();
}
void QSvgTinyDocument::mapSourceToTarget(QPainter *p, const QRectF &targetRect, const QRectF &sourceRect)
{
QRectF target = targetRect;
if (target.isNull()) {
QPaintDevice *dev = p->device();
QRectF deviceRect(0, 0, dev->width(), dev->height());
if (deviceRect.isNull()) {
if (sourceRect.isNull())
target = QRectF(QPointF(0, 0), size());
else
target = QRectF(QPointF(0, 0), sourceRect.size());
} else {
target = deviceRect;
}
}
QRectF source = sourceRect;
if (source.isNull())
source = viewBox();
if (source != target && !source.isNull()) {
QTransform transform;
transform.scale(target.width() / source.width(),
target.height() / source.height());
QRectF c2 = transform.mapRect(source);
p->translate(target.x() - c2.x(),
target.y() - c2.y());
p->scale(target.width() / source.width(),
target.height() / source.height());
}
}
void TestState::frame(double interp) {
Vec2 screenSize = _game->screenSize().template cast<float>();
Vec2 viewCenter = _obj->posInterp(interp);
Boxf viewBox(viewCenter - screenSize / 2,
viewCenter + screenSize / 2);
Boxf screenBox(Vec2::Zero(), screenSize);
_scene.beginRender();
if(_scene.level().nLayers() > 0) {
_scene.renderLevelLayer(0, viewBox, screenBox);
}
_scene.render(interp, viewBox, screenBox);
for(unsigned layer = 1; layer < _scene.level().nLayers(); ++layer) {
_scene.renderLevelLayer(layer, viewBox, screenBox);
}
_font.render(_game, 100, 400, "Hello World !");
_font.render(_game, 100, 432,
"A quite long string in a box a bit too small.", 200);
_scene.endRender();
}
void SplashState::resizeEvent() {
Box3 viewBox(Vector3::Zero(),
Vector3(1080 * window()->width() / window()->height(),
1080,
1));
_camera.setViewBox(viewBox);
renderer()->context()->viewport(0, 0, window()->width(), window()->height());
}
TransformationMatrix SVGFitToViewBox::viewBoxToViewTransform(float viewWidth, float viewHeight) const
{
FloatRect viewBoxRect = viewBox();
if (!viewBoxRect.width() || !viewBoxRect.height())
return TransformationMatrix();
return preserveAspectRatio()->getCTM(viewBoxRect.x(),
viewBoxRect.y(), viewBoxRect.width(), viewBoxRect.height(),
0, 0, viewWidth, viewHeight);
}
RenderObject* SVGSVGElement::createRenderer(RenderArena* arena, RenderStyle*)
{
RenderSVGContainer* rootContainer = new (arena) RenderSVGContainer(this);
// FIXME: All this setup should be done after attributesChanged, not here.
rootContainer->setViewBox(viewBox());
rootContainer->setAlign(KCAlign(preserveAspectRatio()->align() - 1));
rootContainer->setSlice(preserveAspectRatio()->meetOrSlice() == SVGPreserveAspectRatio::SVG_MEETORSLICE_SLICE);
return rootContainer;
}
SVGPreserveAspectRatio* SVGSVGElement::currentPreserveAspectRatio() const {
if (m_viewSpec)
return m_viewSpec->preserveAspectRatio();
if (!viewBox()->currentValue()->isValid() && shouldSynthesizeViewBox()) {
// If no viewBox is specified and we're embedded through SVGImage, then
// synthesize a pAR with the value 'none'.
SVGPreserveAspectRatio* synthesizedPAR = SVGPreserveAspectRatio::create();
synthesizedPAR->setAlign(
SVGPreserveAspectRatio::kSvgPreserveaspectratioNone);
return synthesizedPAR;
}
return preserveAspectRatio()->currentValue();
}
AffineTransform SVGSVGElement::viewBoxToViewTransform(float viewWidth, float viewHeight) const
{
FloatRect viewBoxRect;
if (useCurrentView()) {
if (currentView()) // what if we should use it but it is not set?
viewBoxRect = currentView()->viewBox();
} else
viewBoxRect = viewBox();
AffineTransform ctm = SVGFitToViewBox::viewBoxToViewTransform(viewBoxRect, preserveAspectRatio(), viewWidth, viewHeight);
if (useCurrentView() && currentView())
return currentView()->transform()->concatenate().matrix() * ctm;
return ctm;
}
void SVGSVGElement::parseMappedAttribute(MappedAttribute* attr)
{
if (!nearestViewportElement()) {
// Only handle events if we're the outermost <svg> element
if (attr->name() == onunloadAttr)
addSVGWindowEventListener(unloadEvent, attr);
else if (attr->name() == onabortAttr)
addSVGWindowEventListener(abortEvent, attr);
else if (attr->name() == onerrorAttr)
addSVGWindowEventListener(errorEvent, attr);
else if (attr->name() == onresizeAttr)
addSVGWindowEventListener(resizeEvent, attr);
else if (attr->name() == onscrollAttr)
addSVGWindowEventListener(scrollEvent, attr);
else if (attr->name() == SVGNames::onzoomAttr)
addSVGWindowEventListener(zoomEvent, attr);
}
if (attr->name() == SVGNames::xAttr)
setXBaseValue(SVGLength(this, LengthModeWidth, attr->value()));
else if (attr->name() == SVGNames::yAttr)
setYBaseValue(SVGLength(this, LengthModeHeight, attr->value()));
else if (attr->name() == SVGNames::widthAttr) {
setWidthBaseValue(SVGLength(this, LengthModeWidth, attr->value()));
addCSSProperty(attr, CSS_PROP_WIDTH, attr->value());
if (width().value() < 0.0)
document()->accessSVGExtensions()->reportError("A negative value for svg attribute <width> is not allowed");
} else if (attr->name() == SVGNames::heightAttr) {
setHeightBaseValue(SVGLength(this, LengthModeHeight, attr->value()));
addCSSProperty(attr, CSS_PROP_HEIGHT, attr->value());
if (height().value() < 0.0)
document()->accessSVGExtensions()->reportError("A negative value for svg attribute <height> is not allowed");
} else {
if (SVGTests::parseMappedAttribute(attr))
return;
if (SVGLangSpace::parseMappedAttribute(attr))
return;
if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
return;
if (SVGFitToViewBox::parseMappedAttribute(attr) && renderer()) {
static_cast<RenderSVGContainer*>(renderer())->setViewBox(viewBox());
return;
}
if (SVGZoomAndPan::parseMappedAttribute(attr))
return;
SVGStyledLocatableElement::parseMappedAttribute(attr);
}
}
/*!
Draw the SVG item
\param painter Painter
\param xMap X-Scale Map
\param yMap Y-Scale Map
\param canvasRect Contents rect of the plot canvas
*/
void QwtPlotSvgItem::draw(QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
const QRect &canvasRect) const
{
const QwtDoubleRect cRect = invTransform(xMap, yMap, canvasRect);
const QwtDoubleRect bRect = boundingRect();
if ( bRect.isValid() && cRect.isValid() )
{
QwtDoubleRect rect = bRect;
if ( bRect.contains(cRect) )
rect = cRect;
render(painter, viewBox(rect),
transform(xMap, yMap, rect) );
}
}
SVGViewSpec::SVGViewSpec(SVGSVGElement* contextElement)
// Note: addToPropertyMap is not needed, as SVGViewSpec do not correspond to an element.
// Note: We make tear-offs' contextElement the target element of SVGViewSpec.
// This contextElement will be only used for keeping this alive from the tearoff.
// SVGSVGElement holds a strong-ref to this SVGViewSpec, so this is kept alive as:
// AnimatedProperty tearoff -(contextElement)-> SVGSVGElement -(RefPtr)-> SVGViewSpec.
: SVGFitToViewBox(contextElement, PropertyMapPolicySkip)
, m_contextElement(contextElement)
, m_transform(SVGAnimatedTransformList::create(contextElement, SVGNames::transformAttr, SVGTransformList::create()))
{
ASSERT(m_contextElement);
viewBox()->setReadOnly();
preserveAspectRatio()->setReadOnly();
m_transform->setReadOnly();
// Note: addToPropertyMap is not needed, as SVGViewSpec do not correspond to an element.
}
/*!
Draw the SVG item
\param painter Painter
\param xMap X-Scale Map
\param yMap Y-Scale Map
\param canvasRect Contents rect of the plot canvas
*/
void QwtPlotSvgItem::draw( QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
const QRectF &canvasRect ) const
{
const QRectF cRect = QwtScaleMap::invTransform(
xMap, yMap, canvasRect.toRect() );
const QRectF bRect = boundingRect();
if ( bRect.isValid() && cRect.isValid() )
{
QRectF rect = bRect;
if ( bRect.contains( cRect ) )
rect = cRect;
const QRectF r = QwtScaleMap::transform( xMap, yMap, rect );
render( painter, viewBox( rect ), r );
}
}
FloatRect SVGSVGElement::currentViewBoxRect() const
{
if (m_useCurrentView)
return m_viewSpec ? m_viewSpec->viewBox()->currentValue()->value() : FloatRect();
FloatRect useViewBox = viewBox()->currentValue()->value();
if (!useViewBox.isEmpty())
return useViewBox;
if (!layoutObject() || !layoutObject()->isSVGRoot())
return FloatRect();
if (!toLayoutSVGRoot(layoutObject())->isEmbeddedThroughSVGImage())
return FloatRect();
// If no viewBox is specified but non-relative width/height values, then we
// should always synthesize a viewBox if we're embedded through a SVGImage.
return FloatRect(FloatPoint(), FloatSize(floatValueForLength(intrinsicWidth(), 0), floatValueForLength(intrinsicHeight(), 0)));
}
void SVGSVGElement::inheritViewAttributes(SVGViewElement* viewElement)
{
setUseCurrentView(true);
if (viewElement->hasAttribute(SVGNames::viewBoxAttr))
currentView()->setViewBox(viewElement->viewBox());
else
currentView()->setViewBox(viewBox());
if (viewElement->hasAttribute(SVGNames::preserveAspectRatioAttr)) {
currentView()->preserveAspectRatio()->setAlign(viewElement->preserveAspectRatio()->align());
currentView()->preserveAspectRatio()->setMeetOrSlice(viewElement->preserveAspectRatio()->meetOrSlice());
} else {
currentView()->preserveAspectRatio()->setAlign(preserveAspectRatio()->align());
currentView()->preserveAspectRatio()->setMeetOrSlice(preserveAspectRatio()->meetOrSlice());
}
if (viewElement->hasAttribute(SVGNames::zoomAndPanAttr))
currentView()->setZoomAndPan(viewElement->zoomAndPan());
renderer()->setNeedsLayout(true);
}
void SVGSVGElement::inheritViewAttributes(SVGViewElement* viewElement)
{
setUseCurrentView(true);
if (viewElement->hasAttribute(SVGNames::viewBoxAttr))
currentView()->setViewBox(viewElement->viewBox());
else
currentView()->setViewBox(viewBox());
SVGPreserveAspectRatio aspectRatio;
if (viewElement->hasAttribute(SVGNames::preserveAspectRatioAttr))
aspectRatio = viewElement->preserveAspectRatioBaseValue();
else
aspectRatio = preserveAspectRatioBaseValue();
currentView()->setPreserveAspectRatioBaseValue(aspectRatio);
if (viewElement->hasAttribute(SVGNames::zoomAndPanAttr))
currentView()->setZoomAndPan(viewElement->zoomAndPan());
renderer()->setNeedsLayout(true);
}
TransformationMatrix SVGSVGElement::viewBoxToViewTransform(float viewWidth, float viewHeight) const
{
FloatRect viewBoxRect;
if (useCurrentView()) {
if (currentView()) // what if we should use it but it is not set?
viewBoxRect = currentView()->viewBox();
} else
viewBoxRect = viewBox();
if (!viewBoxRect.width() || !viewBoxRect.height())
return TransformationMatrix();
TransformationMatrix ctm = preserveAspectRatio()->getCTM(viewBoxRect.x(),
viewBoxRect.y(), viewBoxRect.width(), viewBoxRect.height(),
0, 0, viewWidth, viewHeight);
if (useCurrentView() && currentView())
return currentView()->transform()->concatenate().matrix() * ctm;
return ctm;
}
void SVGSVGElement::inheritViewAttributes(SVGViewElement* viewElement)
{
setUseCurrentView(true);
if (viewElement->hasAttribute(SVGNames::viewBoxAttr))
currentView()->setViewBox(viewElement->viewBox());
else
currentView()->setViewBox(viewBox());
SVGPreserveAspectRatio aspectRatio;
if (viewElement->hasAttribute(SVGNames::preserveAspectRatioAttr))
aspectRatio = viewElement->preserveAspectRatioBaseValue();
else
aspectRatio = preserveAspectRatioBaseValue();
currentView()->setPreserveAspectRatioBaseValue(aspectRatio);
if (viewElement->hasAttribute(SVGNames::zoomAndPanAttr))
currentView()->setZoomAndPan(viewElement->zoomAndPan());
if (RenderObject* object = renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(object);
}
FloatRect SVGSVGElement::currentViewBoxRect() const {
if (m_viewSpec)
return m_viewSpec->viewBox()->value();
FloatRect useViewBox = viewBox()->currentValue()->value();
if (!useViewBox.isEmpty())
return useViewBox;
if (!shouldSynthesizeViewBox())
return FloatRect();
// If no viewBox is specified but non-relative width/height values, then we
// should always synthesize a viewBox if we're embedded through a SVGImage.
FloatSize synthesizedViewBoxSize(intrinsicWidth(), intrinsicHeight());
if (!hasIntrinsicWidth())
synthesizedViewBoxSize.setWidth(width()->currentValue()->scaleByPercentage(
currentViewportSize().width()));
if (!hasIntrinsicHeight())
synthesizedViewBoxSize.setHeight(
height()->currentValue()->scaleByPercentage(
currentViewportSize().height()));
return FloatRect(FloatPoint(), synthesizedViewBoxSize);
}
AffineTransform SVGMarkerElement::viewBoxToViewTransform(float viewWidth, float viewHeight) const
{
return SVGFitToViewBox::viewBoxToViewTransform(viewBox(), preserveAspectRatio(), viewWidth, viewHeight);
}
#include <QPainter>
#include <QApplication>
#include "embeddedsvgviewer.h"
EmbeddedSvgViewer::EmbeddedSvgViewer(const QString &filePath)
{
qApp->setStyleSheet(" QSlider:vertical { width: 50px; } \
QSlider::groove:vertical { border: 1px solid black; border-radius: 3px; width: 6px; } \
QSlider::handle:vertical { height: 25px; margin: 0 -22px; image: url(':/files/v-slider-handle.svg'); } \
");
m_renderer = new QSvgRenderer(filePath);
m_imageSize = m_renderer->viewBox().size();
m_viewBoxCenter = (QPointF(m_imageSize.width() / qreal(2.0), m_imageSize.height() / qreal(2.0)));
m_zoomSlider = new QSlider(Qt::Vertical, this);
m_zoomSlider->setMaximum(150);
m_zoomSlider->setMinimum(1);
connect(m_zoomSlider, SIGNAL(valueChanged(int)), this, SLOT(setZoom(int)));
m_zoomSlider->setValue(100);
m_quitButton = new QPushButton("Quit", this);
connect(m_quitButton, SIGNAL(pressed()), QApplication::instance(), SLOT(quit()));
if (m_renderer->animated())
void RenderSVGContainer::paint(PaintInfo& paintInfo, int parentX, int parentY)
{
if (paintInfo.context->paintingDisabled())
return;
// This should only exist for <svg> renderers
if (hasBoxDecorations() && (paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection))
paintBoxDecorations(paintInfo, m_x + parentX, m_y + parentY);
if ((paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline) && style()->outlineWidth() && style()->visibility() == VISIBLE)
paintOutline(paintInfo.context, parentX, parentY, width(), height(), style());
if (paintInfo.phase != PaintPhaseForeground || !drawsContents())
return;
const SVGRenderStyle* svgStyle = style()->svgStyle();
AtomicString filterId(SVGURIReference::getTarget(svgStyle->filter()));
#if ENABLE(SVG_EXPERIMENTAL_FEATURES)
SVGResourceFilter* filter = getFilterById(document(), filterId);
#endif
if (!firstChild()
#if ENABLE(SVG_EXPERIMENTAL_FEATURES)
&& !filter
#endif
)
return; // Spec: groups w/o children still may render filter content.
paintInfo.context->save();
if (!parent()->isSVGContainer()) {
// Translate from parent offsets (html renderers) to a relative transform (svg renderers)
IntPoint origin;
origin.move(parentX, parentY);
origin.move(m_x, m_y);
origin.move(borderLeft(), borderTop());
origin.move(paddingLeft(), paddingTop());
if (origin.x() || origin.y()) {
paintInfo.context->concatCTM(AffineTransform().translate(origin.x(), origin.y()));
paintInfo.rect.move(-origin.x(), -origin.y());
}
parentX = parentY = 0;
SVGSVGElement* svg = static_cast<SVGSVGElement*>(element());
paintInfo.context->concatCTM(AffineTransform().scale(svg->currentScale()));
} else {
// Only the root <svg> element should need any translations using the HTML/CSS system
// parentX, parentY are also non-zero for first-level kids of these
// CSS-transformed <svg> root-elements (due to RenderBox::paint) for any other element
// they should be 0. m_x, m_y should always be 0 for non-root svg containers
ASSERT(m_x == 0);
ASSERT(m_y == 0);
}
if (!viewport().isEmpty()) {
if (style()->overflowX() != OVISIBLE)
paintInfo.context->clip(enclosingIntRect(viewport())); // FIXME: Eventually we'll want float-precision clipping
paintInfo.context->concatCTM(AffineTransform().translate(viewport().x(), viewport().y()));
}
if (!localTransform().isIdentity())
paintInfo.context->concatCTM(localTransform());
if (!parent()->isSVGContainer()) {
SVGSVGElement* svg = static_cast<SVGSVGElement*>(element());
paintInfo.context->concatCTM(AffineTransform().translate(svg->currentTranslate().x(), svg->currentTranslate().y()));
}
FloatRect strokeBBox = relativeBBox(true);
SVGElement* svgElement = static_cast<SVGElement*>(element());
ASSERT(svgElement && svgElement->document() && svgElement->isStyled());
SVGStyledElement* styledElement = static_cast<SVGStyledElement*>(svgElement);
AtomicString clipperId(SVGURIReference::getTarget(svgStyle->clipPath()));
AtomicString maskerId(SVGURIReference::getTarget(svgStyle->maskElement()));
SVGResourceClipper* clipper = getClipperById(document(), clipperId);
SVGResourceMasker* masker = getMaskerById(document(), maskerId);
if (clipper) {
clipper->addClient(styledElement);
clipper->applyClip(paintInfo.context, strokeBBox);
} else if (!clipperId.isEmpty())
svgElement->document()->accessSVGExtensions()->addPendingResource(clipperId, styledElement);
if (masker) {
masker->addClient(styledElement);
masker->applyMask(paintInfo.context, strokeBBox);
} else if (!maskerId.isEmpty())
svgElement->document()->accessSVGExtensions()->addPendingResource(maskerId, styledElement);
float opacity = style()->opacity();
if (opacity < 1.0f) {
paintInfo.context->clip(enclosingIntRect(strokeBBox));
paintInfo.context->beginTransparencyLayer(opacity);
}
#if ENABLE(SVG_EXPERIMENTAL_FEATURES)
if (filter)
filter->prepareFilter(paintInfo.context, strokeBBox);
else if (!filterId.isEmpty())
svgElement->document()->accessSVGExtensions()->addPendingResource(filterId, styledElement);
#endif
if (!viewBox().isEmpty())
paintInfo.context->concatCTM(viewportTransform());
RenderContainer::paint(paintInfo, 0, 0);
#if ENABLE(SVG_EXPERIMENTAL_FEATURES)
if (filter)
filter->applyFilter(paintInfo.context, strokeBBox);
#endif
if (opacity < 1.0f)
paintInfo.context->endTransparencyLayer();
paintInfo.context->restore();
}
