#include "config.h"
#if ENABLE(SVG)
#include "SVGImage.h"
#include "CachedPage.h"
#include "DocumentLoader.h"
#include "EmptyClients.h"
#include "FileChooser.h"
#include "FileIconLoader.h"
#include "FloatRect.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "FrameView.h"
#include "GraphicsContext.h"
#include "HTMLFormElement.h"
#include "ImageBuffer.h"
#include "ImageObserver.h"
#include "Length.h"
#include "Page.h"
#include "RenderSVGRoot.h"
#include "RenderView.h"
#include "ResourceError.h"
#include "SVGDocument.h"
#include "SVGLength.h"
#include "SVGRenderSupport.h"
#include "SVGSVGElement.h"
#include "Settings.h"
namespace WebCore {
class SVGImageChromeClient : public EmptyChromeClient {
WTF_MAKE_NONCOPYABLE(SVGImageChromeClient); WTF_MAKE_FAST_ALLOCATED;
public:
SVGImageChromeClient(SVGImage* image)
: m_image(image)
{
}
virtual bool isSVGImageChromeClient() const { return true; }
SVGImage* image() const { return m_image; }
private:
virtual void chromeDestroyed()
{
m_image = 0;
}
virtual void invalidateContentsAndRootView(const IntRect& r, bool)
{
if (m_image && m_image->imageObserver() && m_image->m_page)
m_image->imageObserver()->changedInRect(m_image, r);
}
SVGImage* m_image;
};
SVGImage::SVGImage(ImageObserver* observer)
: Image(observer)
{
}
SVGImage::~SVGImage()
{
if (m_page) {
OwnPtr<Page> currentPage = m_page.release();
currentPage->mainFrame()->loader()->frameDetached(); }
ASSERT(!m_chromeClient || !m_chromeClient->image());
}
void SVGImage::setContainerSize(const IntSize&)
{
ASSERT_NOT_REACHED();
}
IntSize SVGImage::size() const
{
if (!m_page)
return IntSize();
Frame* frame = m_page->mainFrame();
SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
if (!rootElement)
return IntSize();
RenderSVGRoot* renderer = toRenderSVGRoot(rootElement->renderer());
if (!renderer)
return IntSize();
IntSize containerSize = renderer->containerSize();
if (!containerSize.isEmpty())
return containerSize;
ASSERT(renderer->style()->effectiveZoom() == 1);
FloatSize currentSize;
if (rootElement->intrinsicWidth().isFixed() && rootElement->intrinsicHeight().isFixed())
currentSize = rootElement->currentViewportSize();
else
currentSize = rootElement->currentViewBoxRect().size();
if (!currentSize.isEmpty())
return IntSize(static_cast<int>(ceilf(currentSize.width())), static_cast<int>(ceilf(currentSize.height())));
return IntSize(300, 150);
}
void SVGImage::drawSVGToImageBuffer(ImageBuffer* buffer, const IntSize& size, float zoom, float scale, ShouldClearBuffer shouldClear)
{
ASSERT(buffer);
ASSERT(!size.isEmpty());
if (!m_page)
return;
Frame* frame = m_page->mainFrame();
SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
if (!rootElement)
return;
RenderSVGRoot* renderer = toRenderSVGRoot(rootElement->renderer());
if (!renderer)
return;
ImageObserver* observer = imageObserver();
ASSERT(observer);
setImageObserver(0);
frame->view()->beginDisableRepaints();
renderer->setContainerSize(size);
frame->view()->resize(this->size());
if (zoom != 1)
frame->setPageZoomFactor(zoom);
IntRect rect(IntPoint(), size);
if (shouldClear == ClearImageBuffer)
buffer->context()->clearRect(rect);
FloatRect scaledRect(rect);
scaledRect.scale(scale);
draw(buffer->context(), enclosingIntRect(scaledRect), rect, ColorSpaceDeviceRGB, CompositeSourceOver);
if (zoom != 1)
frame->setPageZoomFactor(1);
renderer->setContainerSize(IntSize());
frame->view()->resize(this->size());
if (frame->view()->needsLayout())
frame->view()->layout();
setImageObserver(observer);
frame->view()->endDisableRepaints();
}
void SVGImage::draw(GraphicsContext* context, const FloatRect& dstRect, const FloatRect& srcRect, ColorSpace, CompositeOperator compositeOp)
{
if (!m_page)
return;
FrameView* view = frameView();
GraphicsContextStateSaver stateSaver(*context);
context->setCompositeOperation(compositeOp);
context->clip(enclosingIntRect(dstRect));
if (compositeOp != CompositeSourceOver)
context->beginTransparencyLayer(1);
FloatSize scale(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height());
FloatSize topLeftOffset(srcRect.location().x() * scale.width(), srcRect.location().y() * scale.height());
FloatPoint destOffset = dstRect.location() - topLeftOffset;
context->translate(destOffset.x(), destOffset.y());
context->scale(scale);
view->resize(size());
if (view->needsLayout())
view->layout();
view->paint(context, IntRect(0, 0, view->width(), view->height()));
if (compositeOp != CompositeSourceOver)
context->endTransparencyLayer();
stateSaver.restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
RenderBox* SVGImage::embeddedContentBox() const
{
if (!m_page)
return 0;
Frame* frame = m_page->mainFrame();
SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
if (!rootElement)
return 0;
return toRenderBox(rootElement->renderer());
}
FrameView* SVGImage::frameView() const
{
if (!m_page)
return 0;
return m_page->mainFrame()->view();
}
bool SVGImage::hasRelativeWidth() const
{
if (!m_page)
return false;
Frame* frame = m_page->mainFrame();
SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
if (!rootElement)
return false;
return rootElement->intrinsicWidth().isPercent();
}
bool SVGImage::hasRelativeHeight() const
{
if (!m_page)
return false;
Frame* frame = m_page->mainFrame();
SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
if (!rootElement)
return false;
return rootElement->intrinsicHeight().isPercent();
}
void SVGImage::computeIntrinsicDimensions(Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
{
if (!m_page)
return;
Frame* frame = m_page->mainFrame();
SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
if (!rootElement)
return;
intrinsicWidth = rootElement->intrinsicWidth();
intrinsicHeight = rootElement->intrinsicHeight();
if (rootElement->preserveAspectRatio().align() == SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_NONE)
return;
intrinsicRatio = rootElement->viewBox().size();
if (intrinsicRatio.isEmpty() && intrinsicWidth.isFixed() && intrinsicHeight.isFixed())
intrinsicRatio = FloatSize(floatValueForLength(intrinsicWidth, 0), floatValueForLength(intrinsicHeight, 0));
}
NativeImagePtr SVGImage::nativeImageForCurrentFrame()
{
if (!m_frameCache) {
if (!m_page)
return 0;
OwnPtr<ImageBuffer> buffer = ImageBuffer::create(size(), 1);
if (!buffer) return 0;
draw(buffer->context(), rect(), rect(), ColorSpaceDeviceRGB, CompositeSourceOver);
m_frameCache = buffer->copyImage(CopyBackingStore);
}
return m_frameCache->nativeImageForCurrentFrame();
}
bool SVGImage::dataChanged(bool allDataReceived)
{
if (!data()->size())
return true;
if (allDataReceived) {
static FrameLoaderClient* dummyFrameLoaderClient = new EmptyFrameLoaderClient;
Page::PageClients pageClients;
fillWithEmptyClients(pageClients);
m_chromeClient = adoptPtr(new SVGImageChromeClient(this));
pageClients.chromeClient = m_chromeClient.get();
m_page = adoptPtr(new Page(pageClients));
m_page->settings()->setMediaEnabled(false);
m_page->settings()->setScriptEnabled(false);
m_page->settings()->setPluginsEnabled(false);
RefPtr<Frame> frame = Frame::create(m_page.get(), 0, dummyFrameLoaderClient);
frame->setView(FrameView::create(frame.get()));
frame->init();
FrameLoader* loader = frame->loader();
loader->forceSandboxFlags(SandboxAll);
frame->view()->setCanHaveScrollbars(false); frame->view()->setTransparent(true);
ASSERT(loader->activeDocumentLoader()); loader->activeDocumentLoader()->writer()->setMIMEType("image/svg+xml");
loader->activeDocumentLoader()->writer()->begin(KURL()); loader->activeDocumentLoader()->writer()->addData(data()->data(), data()->size());
loader->activeDocumentLoader()->writer()->end();
}
return m_page;
}
String SVGImage::filenameExtension() const
{
return "svg";
}
}
#endif // ENABLE(SVG)