File indexing completed on 2024-04-28 15:24:19

 /**
  * This file is part of the DOM implementation for KDE.
  *
  * Copyright (C) 2007 Rob Buis <buis@kde.org>
  *           (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * 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 "wtf/Platform.h"
 
 #if ENABLE(SVG)
 #include "SVGInlineTextBox.h"
 
 #include "Document.h"
 /*#include "Editor.h"
 #include "Frame.h"
 #include "GraphicsContext.h"
 #include "InlineFlowBox.h"
 #include "Range.h"*/
 #include "SVGPaintServer.h"
 #include "SVGRootInlineBox.h"
 /*#include "Text.h"*/
 #include "render_line.h"
 
 #include <float.h>
 #include <math.h>
 
 using std::max;
 
 namespace WebCore
 {
 
 SVGInlineTextBox::SVGInlineTextBox(RenderObject *obj)
     : InlineTextBox(obj)
 {
 }
 
 int SVGInlineTextBox::selectionTop()
 {
     return m_y;
 }
 
 int SVGInlineTextBox::selectionHeight()
 {
     return m_height;
 }
 
 SVGRootInlineBox *SVGInlineTextBox::svgRootInlineBox() const
 {
     // qCDebug(KHTML_LOG) << "find inline box";
     // Find associated root inline box
     InlineFlowBox *parentBox = parent();
 
     while (parentBox && !parentBox->isRootInlineBox()) {
         parentBox = parentBox->parent();
     }
 
     ASSERT(parentBox);
     ASSERT(parentBox->isRootInlineBox());
 
     if (!parentBox->isSVGRootInlineBox()) {
         return nullptr;
     }
 
     return static_cast<SVGRootInlineBox *>(parentBox);
 }
 
 float SVGInlineTextBox::calculateGlyphWidth(RenderStyle *style, int offset, int extraCharsAvailable, int &charsConsumed, String &glyphName) const
 {
     ASSERT(style);
     return style->htmlFont().floatWidth(renderText()->text(), offset, 1, extraCharsAvailable, charsConsumed, glyphName);
     //return style->htmlFont().floatWidth(svgTextRunForInlineTextBox(renderText()->text() + offset, 1, style, this, 0), extraCharsAvailable, charsConsumed, glyphName);
 }
 
 float SVGInlineTextBox::calculateGlyphHeight(RenderStyle *style, int offset, int extraCharsAvailable) const
 {
     Q_UNUSED(offset);
     Q_UNUSED(extraCharsAvailable);
     ASSERT(style);
 
     // This is just a guess, and the only purpose of this function is to centralize this hack.
     // In real-life top-top-bottom scripts this won't be enough, I fear.
     return style->htmlFont().ascent() + style->htmlFont().descent();
 }
 
 FloatRect SVGInlineTextBox::calculateGlyphBoundaries(RenderStyle *style, int offset, const SVGChar &svgChar) const
 {
     const Font &font = style->htmlFont();
 
     // Take RTL text into account and pick right glyph width/height.
     float glyphWidth = 0.0f;
 
     // FIXME: account for multi-character glyphs
     int charsConsumed;
     String glyphName;
     if (!m_reversed) {
         glyphWidth = calculateGlyphWidth(style, offset, 0, charsConsumed, glyphName);
     } else {
         glyphWidth = calculateGlyphWidth(style, start() + end() - offset, 0, charsConsumed, glyphName);
     }
 
     float x1 = svgChar.x;
     float x2 = svgChar.x + glyphWidth;
 
     float y1 = svgChar.y - font.ascent();
     float y2 = svgChar.y + font.descent();
 
     FloatRect glyphRect(x1, y1, x2 - x1, y2 - y1);
 
     // Take per-character transformations into account
     AffineTransform ctm = svgChar.characterTransform();
     if (!ctm.isIdentity()) {
         glyphRect = ctm.mapRect(glyphRect);
     }
 
     return glyphRect;
 }
 
 // Helper class for closestCharacterToPosition()
 struct SVGInlineTextBoxClosestCharacterToPositionWalker {
     SVGInlineTextBoxClosestCharacterToPositionWalker(int x, int y)
         : m_character(nullptr)
         , m_distance(FLT_MAX)
         , m_x(x)
         , m_y(y)
         , m_offset(0)
     {
     }
 
     void chunkPortionCallback(SVGInlineTextBox *textBox, int startOffset, const AffineTransform &chunkCtm,
                               const Vector<SVGChar>::iterator &start, const Vector<SVGChar>::iterator &end)
     {
         RenderStyle *style = textBox->renderText()->style();
 
         Vector<SVGChar>::iterator closestCharacter = nullptr;
         unsigned int closestOffset = UINT_MAX;
 
         for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
             if (it->isHidden()) {
                 continue;
             }
 
             unsigned int newOffset = textBox->start() + (it - start) + startOffset;
             FloatRect glyphRect = chunkCtm.mapRect(textBox->calculateGlyphBoundaries(style, newOffset, *it));
 
             // Take RTL text into account and pick right glyph width/height.
             // NOTE: This offset has to be corrected _after_ calling calculateGlyphBoundaries
             if (textBox->m_reversed) {
                 newOffset = textBox->start() + textBox->end() - newOffset;
             }
 
             // Calculate distances relative to the glyph mid-point. I hope this is accurate enough.
             float xDistance = glyphRect.x() + glyphRect.width() / 2.0f - m_x;
             float yDistance = glyphRect.y() - glyphRect.height() / 2.0f - m_y;
 
             float newDistance = sqrtf(xDistance * xDistance + yDistance * yDistance);
             if (newDistance <= m_distance) {
                 m_distance = newDistance;
                 closestOffset = newOffset;
                 closestCharacter = it;
             }
         }
 
         if (closestOffset != UINT_MAX) {
             // Record current chunk, if it contains the current closest character next to the mouse.
             m_character = closestCharacter;
             m_offset = closestOffset;
         }
     }
 
     SVGChar *character() const
     {
         return m_character;
     }
 
     int offset() const
     {
         if (!m_character) {
             return 0;
         }
 
         return m_offset;
     }
 
 private:
     Vector<SVGChar>::iterator m_character;
     float m_distance;
 
     int m_x;
     int m_y;
     int m_offset;
 };
 
 // Helper class for selectionRect()
 struct SVGInlineTextBoxSelectionRectWalker {
     SVGInlineTextBoxSelectionRectWalker()
     {
     }
 
     void chunkPortionCallback(SVGInlineTextBox *textBox, int startOffset, const AffineTransform &chunkCtm,
                               const Vector<SVGChar>::iterator &start, const Vector<SVGChar>::iterator &end)
     {
         RenderStyle *style = textBox->renderText()->style();
 
         for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
             if (it->isHidden()) {
                 continue;
             }
 
             unsigned int newOffset = textBox->start() + (it - start) + startOffset;
             m_selectionRect.unite(textBox->calculateGlyphBoundaries(style, newOffset, *it));
         }
 
         m_selectionRect = chunkCtm.mapRect(m_selectionRect);
     }
 
     FloatRect selectionRect() const
     {
         return m_selectionRect;
     }
 
 private:
     FloatRect m_selectionRect;
 };
 
 SVGChar *SVGInlineTextBox::closestCharacterToPosition(int x, int y, int &offset) const
 {
     SVGRootInlineBox *rootBox = svgRootInlineBox();
     if (!rootBox) {
         return nullptr;
     }
 
     SVGInlineTextBoxClosestCharacterToPositionWalker walkerCallback(x, y);
     SVGTextChunkWalker<SVGInlineTextBoxClosestCharacterToPositionWalker> walker(&walkerCallback, &SVGInlineTextBoxClosestCharacterToPositionWalker::chunkPortionCallback);
 
     rootBox->walkTextChunks(&walker, this);
 
     offset = walkerCallback.offset();
     return walkerCallback.character();
 }
 
 bool SVGInlineTextBox::svgCharacterHitsPosition(int x, int y, int &offset) const
 {
     SVGChar *charAtPosPtr = closestCharacterToPosition(x, y, offset);
     if (!charAtPosPtr) {
         return false;
     }
 
     SVGChar &charAtPos = *charAtPosPtr;
     RenderStyle *style = renderText()->style(m_firstLine);
     FloatRect glyphRect = calculateGlyphBoundaries(style, offset, charAtPos);
 
     if (m_reversed) {
         offset++;
     }
 
     // FIXME: todo list
     // (#13910) This code does not handle bottom-to-top/top-to-bottom vertical text.
 
     // Check whether y position hits the current character
     if (y < charAtPos.y - glyphRect.height() || y > charAtPos.y) {
         return false;
     }
 
     // Check whether x position hits the current character
     if (x < charAtPos.x) {
         if (offset > 0 && !m_reversed) {
             return true;
         } else if (offset < (int) end() && m_reversed) {
             return true;
         }
 
         return false;
     }
 
     // If we are past the last glyph of this box, don't mark it as 'hit' anymore.
     if (x >= charAtPos.x + glyphRect.width() && offset == (int) end()) {
         return false;
     }
 
     // Snap to character at half of it's advance
     if (x >= charAtPos.x + glyphRect.width() / 2.0) {
         offset += m_reversed ? -1 : 1;
     }
 
     return true;
 }
 
 int SVGInlineTextBox::offsetForPosition(int x, bool includePartialGlyphs) const
 {
     Q_UNUSED(x);
     Q_UNUSED(includePartialGlyphs);
     // SVG doesn't use the offset <-> position selection system.
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 int SVGInlineTextBox::positionForOffset(int offset) const
 {
     Q_UNUSED(offset);
     // SVG doesn't use the offset <-> position selection system.
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 /*bool SVGInlineTextBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, int x, int y, int tx, int ty)
 {
     ASSERT(!isLineBreak());
 
     IntRect rect = selectionRect(0, 0, 0, len());
     if (object()->style()->visibility() == VISIBLE && rect.contains(x, y)) {
         object()->updateHitTestResult(result, IntPoint(x - tx, y - ty));
         return true;
     }
 
     return false;
 }*/
 
 IntRect SVGInlineTextBox::selectionRect(int, int, int startPos, int endPos)
 {
     if (startPos >= endPos) {
         return IntRect();
     }
 
     // TODO: Actually respect startPos/endPos - we're returning the _full_ selectionRect
     // here. This won't lead to visible bugs, but to extra work being done. Investigate.
     SVGRootInlineBox *rootBox = svgRootInlineBox();
     if (!rootBox) {
         return IntRect();
     }
 
     SVGInlineTextBoxSelectionRectWalker walkerCallback;
     SVGTextChunkWalker<SVGInlineTextBoxSelectionRectWalker> walker(&walkerCallback, &SVGInlineTextBoxSelectionRectWalker::chunkPortionCallback);
 
     rootBox->walkTextChunks(&walker, this);
     return enclosingIntRect(walkerCallback.selectionRect());
 }
 
 void SVGInlineTextBox::paintCharacters(RenderObject::PaintInfo &paintInfo, int tx, int ty, const SVGChar &svgChar, const UChar *chars, int length, SVGPaintServer *activePaintServer)
 {
     Q_UNUSED(tx);
     Q_UNUSED(ty);
     Q_UNUSED(chars);
     Q_UNUSED(length);
     Q_UNUSED(activePaintServer);
     // qCDebug(KHTML_LOG) << "paint character";
     /*FIXME khtml if (object()->style()->visibility() != VISIBLE || paintInfo.phase == PaintPhaseOutline)
         return;
 
     ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);*/
 
     RenderText *text = renderText();
     ASSERT(text);
 
     // Determine whether or not we're selected.
     bool haveSelection = text->selectionState() != RenderObject::SelectionNone;
     if (!haveSelection && paintInfo.phase == PaintActionSelection)
         // When only painting the selection, don't bother to paint if there is none.
     {
         return;
     }
 
     // Determine whether or not we have a composition.
     /*bool containsComposition = text->document()->frame()->editor()->compositionNode() == text->node();
     bool useCustomUnderlines = containsComposition && text->document()->frame()->editor()->compositionUsesCustomUnderlines();*/
 
     // Set our font
     RenderStyle *styleToUse = text->style(m_firstLine);
     const Font *font = &styleToUse->htmlFont();
     if (styleToUse->font() != paintInfo.p->font()) {
         paintInfo.p->setFont(styleToUse->font());
     }
 
     AffineTransform ctm = svgChar.characterTransform();
     if (!ctm.isIdentity()) {
         paintInfo.p->setWorldMatrix(ctm, true);
     }
     //paintInfo.context->concatCTM(ctm);
 
     // 1. Paint backgrounds behind text if needed.  Examples of such backgrounds include selection
     // and marked text.
     if (true/*paintInfo.phase != PaintPhaseSelection && !isPrinting*/) {
 #if PLATFORM(MAC)
         // Custom highlighters go behind everything else.
         if (styleToUse->highlight() != nullAtom && !paintInfo.context->paintingDisabled()) {
             paintCustomHighlight(tx, ty, styleToUse->highlight());
         }
 #endif
 
         /*FIXME khtml if (containsComposition && !useCustomUnderlines)
             paintCompositionBackground(paintInfo.context, tx, ty, styleToUse, font,
                                                 text->document()->frame()->editor()->compositionStart(),
                                                 text->document()->frame()->editor()->compositionEnd());
 
         paintDocumentMarkers(paintInfo.context, tx, ty, styleToUse, font, true);*/
 
         /*if (haveSelection && !useCustomUnderlines) {
             int boxStartOffset = chars - text->characters() - start();
             //FIXME khtml paintSelection(boxStartOffset, svgChar, chars, length, paintInfo.context, styleToUse, font);
         }*/
     }
 
     // Set a text shadow if we have one.
     // FIXME: Support multiple shadow effects.  Need more from the CG API before
     // we can do this.
     //bool setShadow = false;
     if (styleToUse->textShadow()) {
         /*FIXME khtml paintInfo.context->setShadow(IntSize(styleToUse->textShadow()->x, styleToUse->textShadow()->y),
                                      styleToUse->textShadow()->blur, styleToUse->textShadow()->color);
         setShadow = true;*/
     }
 
     IntPoint origin((int) svgChar.x, (int) svgChar.y);
     // qCDebug(KHTML_LOG) << "origin: " << svgChar.x << svgChar.y;
     //TextRun run = svgTextRunForInlineTextBox(chars, length, styleToUse, this, svgChar.x);
 
 #if ENABLE(SVG_FONTS)
     // SVG Fonts need access to the paint server used to draw the current text chunk.
     // They need to be able to call renderPath() on a SVGPaintServer object.
     //FIXME khtml run.setActivePaintServer(activePaintServer);
 #endif
 
     //FIXME khtml paintInfo.context->drawText(run, origin);
     // qCDebug(KHTML_LOG) << "font size:" << font->getFontDef().size;
     // qCDebug(KHTML_LOG) << "text:" << QString::fromRawData(renderText()->string()->s + m_start, m_len);
 
     font->drawText(paintInfo.p, svgChar.x, svgChar.y, renderText()->string()->s, renderText()->string()->l, m_start, m_len,
                    m_toAdd, m_reversed ? Qt::RightToLeft : Qt::LeftToRight);
 
     if (true/*paintInfo.phase != PaintPhaseSelection*/) {
         //FIXME khtml paintDocumentMarkers(paintInfo.context, tx, ty, styleToUse, font, false);
 
         /*if (useCustomUnderlines) {
             const Vector<CompositionUnderline>& underlines = text->document()->frame()->editor()->customCompositionUnderlines();
             size_t numUnderlines = underlines.size();
 
             for (size_t index = 0; index < numUnderlines; ++index) {
                 const CompositionUnderline& underline = underlines[index];
 
                 if (underline.endOffset <= start())
                     // underline is completely before this run.  This might be an underline that sits
                     // before the first run we draw, or underlines that were within runs we skipped
                     // due to truncation.
                     continue;
 
                 if (underline.startOffset <= end()) {
                     // underline intersects this run.  Paint it.
                     //FIXME khtml paintCompositionUnderline(paintInfo.context, tx, ty, underline);
                     if (underline.endOffset > end() + 1)
                         // underline also runs into the next run. Bail now, no more marker advancement.
                         break;
                 } else
                     // underline is completely after this run, bail.  A later run will paint it.
                     break;
             }
         }*/
 
     }
 
     /*if (setShadow)
         paintInfo.context->clearShadow();*/
 
     if (!ctm.isIdentity()) {
         paintInfo.p->setWorldMatrix(ctm.inverse(), true);
     }
     //paintInfo.context->concatCTM(ctm.inverse());
 }
 
 void SVGInlineTextBox::paintSelection(int boxStartOffset, const SVGChar &svgChar, const UChar *chars, int length, khtml::RenderObject::PaintInfo &p, RenderStyle *style, const Font *f)
 {
     Q_UNUSED(boxStartOffset);
     Q_UNUSED(svgChar);
     Q_UNUSED(chars);
     Q_UNUSED(length);
     Q_UNUSED(p);
     Q_UNUSED(style);
     Q_UNUSED(f);
     /*if (selectionState() == RenderObject::SelectionNone)
         return;
 
     int startPos, endPos;
     selectionStartEnd(startPos, endPos);
 
     if (startPos >= endPos)
         return;
 
     Color textColor = style->color();
     Color color = object()->selectionBackgroundColor();
     if (!color.isValid() || color.alpha() == 0)
         return;
 
     // If the text color ends up being the same as the selection background, invert the selection
     // background.  This should basically never happen, since the selection has transparency.
     if (textColor == color)
         color = Color(0xff - color.red(), 0xff - color.green(), 0xff - color.blue());
 
     // Map from text box positions and a given start offset to chunk positions
     // 'boxStartOffset' represents the beginning of the text chunk.
     if ((startPos > boxStartOffset && endPos > boxStartOffset + length) || boxStartOffset >= endPos)
         return;
 
     if (endPos > boxStartOffset + length)
         endPos = boxStartOffset + length;
 
     if (startPos < boxStartOffset)
         startPos = boxStartOffset;
 
     ASSERT(startPos >= boxStartOffset);
     ASSERT(endPos <= boxStartOffset + length);
     ASSERT(startPos < endPos);
 
     p->save();
 
     int adjust = startPos >= boxStartOffset ? boxStartOffset : 0;
     p->drawHighlightForText(svgTextRunForInlineTextBox(textObject()->text()->characters() + start() + boxStartOffset, length, style, this, svgChar.x),
                             IntPoint((int) svgChar.x, (int) svgChar.y - f->ascent()),
                             f->ascent() + f->descent(), color, startPos - adjust, endPos - adjust);
 
     p->restore();*/
 }
 
 static inline Path pathForDecoration(ETextDecoration decoration, RenderObject *object, float x, float y, float width)
 {
     Q_UNUSED(decoration);
 
     float thickness = SVGRenderStyle::cssPrimitiveToLength(object, object->style()->svgStyle()->strokeWidth(), 1.0f);
 
     const Font &font = object->style()->htmlFont();
     thickness = max(thickness * powf(font.getFontDef().size, 2.0f) / font.unitsPerEm(), 1.0f);
 
     if (decoration == UNDERLINE) {
         y += thickness * 1.5f;    // For compatibility with Batik/Opera
     } else if (decoration == OVERLINE) {
         y += thickness;
     }
 
     float halfThickness = thickness / 2.0f;
     return Path::createRectangle(FloatRect(x + halfThickness, y, width - 2.0f * halfThickness, thickness));
 }
 
 void SVGInlineTextBox::paintDecoration(ETextDecoration decoration, khtml::RenderObject::PaintInfo &pI, int tx, int ty, int width, const SVGChar &svgChar, const SVGTextDecorationInfo &info)
 {
     Q_UNUSED(decoration);
     Q_UNUSED(pI);
     Q_UNUSED(tx);
     Q_UNUSED(ty);
     Q_UNUSED(width);
     Q_UNUSED(svgChar);
     Q_UNUSED(info);
 
     /*FIXME if (object()->style()->visibility() != VISIBLE)
         return;
 
     // This function does NOT accept combinated text decorations. It's meant to be invoked for just one.
     ASSERT(decoration == TDNONE || decoration == UNDERLINE || decoration == OVERLINE || decoration == LINE_THROUGH || decoration == BLINK);
 
     bool isFilled = info.fillServerMap.contains(decoration);
     bool isStroked = info.strokeServerMap.contains(decoration);
 
     if (!isFilled && !isStroked)
         return;
 
     if (decoration == UNDERLINE)
         ty += m_baseline;
     else if (decoration == LINE_THROUGH)
         ty += 2 * m_baseline / 3;
 
     context->save();
     context->beginPath();
 
     AffineTransform ctm = svgChar.characterTransform();
     if (!ctm.isIdentity())
         context->concatCTM(ctm);
 
     if (isFilled) {
         if (RenderObject* fillObject = info.fillServerMap.get(decoration)) {
             if (SVGPaintServer* fillPaintServer = SVGPaintServer::fillPaintServer(fillObject->style(), fillObject)) {
                 context->addPath(pathForDecoration(decoration, fillObject, tx, ty, width));
                 fillPaintServer->draw(context, fillObject, ApplyToFillTargetType);
             }
         }
     }
 
     if (isStroked) {
         if (RenderObject* strokeObject = info.strokeServerMap.get(decoration)) {
             if (SVGPaintServer* strokePaintServer = SVGPaintServer::strokePaintServer(strokeObject->style(), strokeObject)) {
                 context->addPath(pathForDecoration(decoration, strokeObject, tx, ty, width));
                 strokePaintServer->draw(context, strokeObject, ApplyToStrokeTargetType);
             }
         }
     }
 
     context->restore();*/
 }
 
 } // namespace WebCore
 
 #endif