| /* |
| * This file is part of the WebKit project. |
| * |
| * Copyright (C) 2006 Oliver Hunt <ojh16@student.canterbury.ac.nz> |
| * (C) 2006 Apple Computer Inc. |
| * |
| * 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., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| * |
| */ |
| |
| #include "config.h" |
| |
| #if ENABLE(SVG) |
| #include "SVGInlineFlowBox.h" |
| |
| #include "GraphicsContext.h" |
| #include "InlineTextBox.h" |
| #include "KCanvasRenderingStyle.h" |
| #include "RootInlineBox.h" |
| #include "SVGLengthList.h" |
| #include "SVGNames.h" |
| #include "SVGPaintServer.h" |
| #include "SVGResourceClipper.h" |
| #include "SVGResourceFilter.h" |
| #include "SVGResourceMasker.h" |
| #include "SVGTextPositioningElement.h" |
| #include "SVGURIReference.h" |
| |
| using std::min; |
| using std::max; |
| |
| namespace WebCore { |
| |
| using namespace SVGNames; |
| |
| void SVGInlineFlowBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty) |
| { |
| paintSVGInlineFlow(this, object(), paintInfo, tx, ty); |
| } |
| |
| int SVGInlineFlowBox::placeBoxesHorizontally(int x, int& leftPosition, int& rightPosition, bool& needsWordSpacing) |
| { |
| return placeSVGFlowHorizontally(this, x, leftPosition, rightPosition, needsWordSpacing); |
| } |
| |
| void SVGInlineFlowBox::verticallyAlignBoxes(int& heightOfBlock) |
| { |
| placeSVGFlowVertically(this, heightOfBlock); |
| } |
| |
| void paintSVGInlineFlow(InlineFlowBox* flow, RenderObject* object, RenderObject::PaintInfo& paintInfo, int tx, int ty) |
| { |
| if (paintInfo.context->paintingDisabled()) |
| return; |
| |
| paintInfo.context->save(); |
| paintInfo.context->concatCTM(object->localTransform()); |
| |
| FloatRect boundingBox(tx + flow->xPos(), ty + flow->yPos(), flow->width(), flow->height()); |
| |
| SVGElement* svgElement = static_cast<SVGElement*>(object->element()); |
| ASSERT(svgElement && svgElement->document() && svgElement->isStyled()); |
| |
| SVGStyledElement* styledElement = static_cast<SVGStyledElement*>(svgElement); |
| const SVGRenderStyle* svgStyle = object->style()->svgStyle(); |
| |
| AtomicString filterId(SVGURIReference::getTarget(svgStyle->filter())); |
| AtomicString clipperId(SVGURIReference::getTarget(svgStyle->clipPath())); |
| AtomicString maskerId(SVGURIReference::getTarget(svgStyle->maskElement())); |
| |
| #if ENABLE(SVG_EXPERIMENTAL_FEATURES) |
| SVGResourceFilter* filter = getFilterById(object->document(), filterId); |
| #endif |
| SVGResourceClipper* clipper = getClipperById(object->document(), clipperId); |
| SVGResourceMasker* masker = getMaskerById(object->document(), maskerId); |
| |
| #if ENABLE(SVG_EXPERIMENTAL_FEATURES) |
| if (filter) |
| filter->prepareFilter(paintInfo.context, boundingBox); |
| else if (!filterId.isEmpty()) |
| svgElement->document()->accessSVGExtensions()->addPendingResource(filterId, styledElement); |
| #endif |
| |
| if (clipper) { |
| clipper->addClient(styledElement); |
| clipper->applyClip(paintInfo.context, boundingBox); |
| } else if (!clipperId.isEmpty()) |
| svgElement->document()->accessSVGExtensions()->addPendingResource(clipperId, styledElement); |
| |
| if (masker) { |
| masker->addClient(styledElement); |
| masker->applyMask(paintInfo.context, boundingBox); |
| } else if (!maskerId.isEmpty()) |
| svgElement->document()->accessSVGExtensions()->addPendingResource(maskerId, styledElement); |
| |
| RenderObject::PaintInfo pi(paintInfo); |
| |
| if (!flow->isRootInlineBox()) |
| pi.rect = (object->localTransform()).inverse().mapRect(pi.rect); |
| |
| float opacity = object->style()->opacity(); |
| if (opacity < 1.0f) { |
| paintInfo.context->clip(enclosingIntRect(boundingBox)); |
| paintInfo.context->beginTransparencyLayer(opacity); |
| } |
| |
| SVGPaintServer* fillPaintServer = KSVGPainterFactory::fillPaintServer(object->style(), object); |
| if (fillPaintServer) { |
| if (fillPaintServer->setup(pi.context, object, ApplyToFillTargetType, true)) { |
| flow->InlineFlowBox::paint(pi, tx, ty); |
| fillPaintServer->teardown(pi.context, object, ApplyToFillTargetType, true); |
| } |
| } |
| |
| SVGPaintServer* strokePaintServer = KSVGPainterFactory::strokePaintServer(object->style(), object); |
| if (strokePaintServer) { |
| if (strokePaintServer->setup(pi.context, object, ApplyToStrokeTargetType, true)) { |
| flow->InlineFlowBox::paint(pi, tx, ty); |
| strokePaintServer->teardown(pi.context, object, ApplyToStrokeTargetType, true); |
| } |
| } |
| |
| #if ENABLE(SVG_EXPERIMENTAL_FEATURES) |
| if (filter) |
| filter->applyFilter(paintInfo.context, boundingBox); |
| #endif |
| |
| if (opacity < 1.0f) |
| paintInfo.context->endTransparencyLayer(); |
| |
| paintInfo.context->restore(); |
| } |
| |
| static bool translateBox(InlineBox* box, int x, int y, bool topLevel) |
| { |
| if (box->object()->isText()) { |
| box->setXPos(box->xPos() + x); |
| box->setYPos(box->yPos() + y); |
| } else if (!box->object()->element()->hasTagName(aTag)) { |
| InlineFlowBox* flow = static_cast<InlineFlowBox*>(box); |
| SVGTextPositioningElement* text = static_cast<SVGTextPositioningElement*>(box->object()->element()); |
| |
| if (topLevel || !(text->x()->getFirst().value() || text->y()->getFirst().value() || |
| text->dx()->getFirst().value() || text->dy()->getFirst().value())) { |
| box->setXPos(box->xPos() + x); |
| box->setYPos(box->yPos() + y); |
| for (InlineBox* curr = flow->firstChild(); curr; curr = curr->nextOnLine()) { |
| if (!translateBox(curr, x, y, false)) |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| static int placePositionedBoxesHorizontally(InlineFlowBox* flow, int x, int& leftPosition, int& rightPosition, int& leftAlign, int& rightAlign, bool& needsWordSpacing, int xPos, bool positioned) |
| { |
| int mn = INT_MAX; |
| int mx = INT_MIN; |
| int amn = INT_MAX; |
| int amx = INT_MIN; |
| int startx = x; |
| bool seenPositionedElement = false; |
| flow->setXPos(x); |
| for (InlineBox* curr = flow->firstChild(); curr; curr = curr->nextOnLine()) { |
| if (curr->object()->isText()) { |
| mn = min(mn, x); |
| amn = min(amn, x); |
| InlineTextBox* text = static_cast<InlineTextBox*>(curr); |
| RenderText* rt = static_cast<RenderText*>(text->object()); |
| if (rt->textLength()) { |
| if (needsWordSpacing && DeprecatedChar(rt->characters()[text->start()]).isSpace()) |
| x += rt->style(flow->isFirstLineStyle())->font().wordSpacing(); |
| needsWordSpacing = !DeprecatedChar(rt->characters()[text->end()]).isSpace(); |
| } |
| text->setXPos(x); |
| x += text->width(); |
| mx = max(mx, x); |
| amx = max(amx, x); |
| } else if (curr->object()->isInlineFlow()) { |
| InlineFlowBox* flow = static_cast<InlineFlowBox*>(curr); |
| if (flow->object()->element()->hasTagName(aTag)) { |
| x = placePositionedBoxesHorizontally(flow, x, mn, mx, amn, amx, needsWordSpacing, xPos, false); |
| } else { |
| SVGTextPositioningElement* text = static_cast<SVGTextPositioningElement*>(flow->object()->element()); |
| x += (int)(text->dx()->getFirst().value()); |
| if (text->x()->numberOfItems() > 0) |
| x = (int)(text->x()->getFirst().value() - xPos); |
| if (text->x()->numberOfItems() > 0 || text->y()->numberOfItems() > 0 || |
| text->dx()->numberOfItems() > 0 || text->dy()->numberOfItems() > 0) { |
| seenPositionedElement = true; |
| needsWordSpacing = false; |
| int ignoreX, ignoreY; |
| x = placePositionedBoxesHorizontally(flow, x, mn, mx, ignoreX, ignoreY, needsWordSpacing, xPos, true); |
| } else if (seenPositionedElement) { |
| int ignoreX, ignoreY; |
| x = placePositionedBoxesHorizontally(flow, x, mn, mx, ignoreX, ignoreY, needsWordSpacing, xPos, false); |
| } else |
| x = placePositionedBoxesHorizontally(flow, x, mn, mx, amn, amx, needsWordSpacing, xPos, false); |
| } |
| } |
| } |
| |
| if (mn > mx) |
| mn = mx = startx; |
| if (amn > amx) |
| amn = amx = startx; |
| |
| int width = mx - mn; |
| flow->setWidth(width); |
| |
| int awidth = amx - amn; |
| int dx = 0; |
| if (positioned) { |
| switch (flow->object()->style()->svgStyle()->textAnchor()) { |
| case TA_MIDDLE: |
| translateBox(flow, dx = -awidth / 2, 0, true); |
| break; |
| case TA_END: |
| translateBox(flow, dx = -awidth, 0, true); |
| break; |
| case TA_START: |
| default: |
| break; |
| } |
| |
| if (dx) { |
| x += dx; |
| mn += dx; |
| mx += dx; |
| } |
| } |
| |
| leftPosition = min(leftPosition, mn); |
| rightPosition = max(rightPosition, mx); |
| leftAlign = min(leftAlign, amn); |
| rightAlign = max(rightAlign, amx); |
| |
| return x; |
| } |
| |
| int placeSVGFlowHorizontally(InlineFlowBox* flow, int x, int& leftPosition, int& rightPosition, bool& needsWordSpacing) |
| { |
| int ignoreX, ignoreY; |
| x = placePositionedBoxesHorizontally(flow, x, leftPosition, rightPosition, ignoreX, ignoreY, needsWordSpacing, flow->object()->xPos(), true); |
| needsWordSpacing = false; |
| return x; |
| } |
| |
| static void placeBoxesVerticallyWithAbsBaseline(InlineFlowBox* flow, int& heightOfBlock, int& minY, int& maxY, int& baseline, int yPos) |
| { |
| for (InlineBox* curr = flow->firstChild(); curr; curr = curr->nextOnLine()) { |
| if (curr->isInlineFlowBox() && !curr->object()->element()->hasTagName(aTag)) { |
| SVGTextPositioningElement* text = static_cast<SVGTextPositioningElement*>(curr->object()->element()); |
| baseline += (int)(text->dy()->getFirst().value()); |
| |
| if (text->y()->numberOfItems() > 0) |
| baseline = (int)(text->y()->getFirst().value() - yPos); |
| |
| placeBoxesVerticallyWithAbsBaseline(static_cast<InlineFlowBox*>(curr), heightOfBlock, minY, maxY, baseline, yPos); |
| } |
| const Font& font = curr->object()->firstLineStyle()->font(); // FIXME: Is it right to always use firstLineStyle here? |
| int ascent = font.ascent(); |
| int position = baseline - ascent; |
| int height = ascent + font.descent(); |
| curr->setBaseline(ascent); |
| curr->setYPos(position); |
| curr->setHeight(height); |
| |
| if (position < minY) |
| minY = position; |
| if (position + height > maxY) |
| maxY = position + height; |
| } |
| |
| if (flow->isRootInlineBox()) { |
| flow->setYPos(minY); |
| flow->setHeight(maxY - minY); |
| flow->setBaseline(baseline - minY); |
| heightOfBlock += maxY - minY; |
| } |
| } |
| |
| void placeSVGFlowVertically(InlineFlowBox* flow, int& heightOfBlock) |
| { |
| int top = INT_MAX; |
| int bottom = INT_MIN; |
| int baseline = heightOfBlock; |
| placeBoxesVerticallyWithAbsBaseline(flow, heightOfBlock, top, bottom, baseline, flow->object()->yPos()); |
| flow->setVerticalOverflowPositions(top, bottom); |
| flow->setVerticalSelectionPositions(top, bottom); |
| } |
| |
| } // namespace WebCore |
| |
| #endif // ENABLE(SVG) |
