8b34c2c599e2a24cead0fba5728748fcb1e80737
[WebKit-https.git] / WebCore / svg / SVGTextContentElement.cpp
1 /*
2     Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
3                   2004, 2005, 2006, 2007, 2008 Rob Buis <buis@kde.org>
4
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Library General Public
7     License as published by the Free Software Foundation; either
8     version 2 of the License, or (at your option) any later version.
9
10     This library is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13     Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public License
16     along with this library; see the file COPYING.LIB.  If not, write to
17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18     Boston, MA 02110-1301, USA.
19 */
20
21 #include "config.h"
22
23 #if ENABLE(SVG)
24 #include "SVGTextContentElement.h"
25
26 #include "CSSPropertyNames.h"
27 #include "CSSValueKeywords.h"
28 #include "ExceptionCode.h"
29 #include "FloatPoint.h"
30 #include "FloatRect.h"
31 #include "Frame.h"
32 #include "Position.h"
33 #include "RenderSVGText.h"
34 #include "SelectionController.h"
35 #include "SVGCharacterLayoutInfo.h"
36 #include "SVGRootInlineBox.h"
37 #include "SVGLength.h"
38 #include "SVGInlineTextBox.h"
39 #include "SVGNames.h"
40 #include "XMLNames.h"
41 #include <wtf/StdLibExtras.h>
42
43 namespace WebCore {
44
45 char SVGTextContentElementIdentifier[] = "SVGTextContentElement";
46
47 SVGTextContentElement::SVGTextContentElement(const QualifiedName& tagName, Document* doc)
48     : SVGStyledElement(tagName, doc)
49     , SVGTests()
50     , SVGLangSpace()
51     , SVGExternalResourcesRequired()
52     , m_textLength(this, SVGNames::textLengthAttr, LengthModeOther)
53     , m_lengthAdjust(this, SVGNames::lengthAdjustAttr, LENGTHADJUST_SPACING)
54 {
55 }
56
57 SVGTextContentElement::~SVGTextContentElement()
58 {
59 }
60
61 static inline float cumulativeCharacterRangeLength(const Vector<SVGChar>::iterator& start, const Vector<SVGChar>::iterator& end, SVGInlineTextBox* textBox,
62                                                    int startOffset, long startPosition, long length, bool isVerticalText, long& atCharacter)
63 {
64     if (!length)
65         return 0.0f;
66
67     float textLength = 0.0f;
68     RenderStyle* style = textBox->textRenderer()->style();
69
70     bool usesFullRange = (startPosition == -1 && length == -1);
71
72     for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
73         if (usesFullRange || (atCharacter >= startPosition && atCharacter <= startPosition + length)) {
74             unsigned int newOffset = textBox->start() + (it - start) + startOffset;
75
76             // Take RTL text into account and pick right glyph width/height.
77             if (textBox->direction() == RTL)
78                 newOffset = textBox->start() + textBox->end() - newOffset;
79
80             // FIXME: does this handle multichar glyphs ok? not sure
81             int charsConsumed = 0;
82             String glyphName;
83             if (isVerticalText)
84                 textLength += textBox->calculateGlyphHeight(style, newOffset, 0);
85             else
86                 textLength += textBox->calculateGlyphWidth(style, newOffset, 0, charsConsumed, glyphName);
87         }
88
89         if (!usesFullRange) {
90             if (atCharacter == startPosition + length - 1)
91                 break;
92
93             atCharacter++;
94         }
95     }
96
97     return textLength;
98 }
99
100 // Helper class for querying certain glyph information
101 struct SVGInlineTextBoxQueryWalker {
102     typedef enum {
103         NumberOfCharacters,
104         TextLength,
105         SubStringLength,
106         StartPosition,
107         EndPosition,
108         Extent,
109         Rotation,
110         CharacterNumberAtPosition
111     } QueryMode;
112
113     SVGInlineTextBoxQueryWalker(const SVGTextContentElement* reference, QueryMode mode)
114         : m_reference(reference)
115         , m_mode(mode)
116         , m_queryStartPosition(0)
117         , m_queryLength(0)
118         , m_queryPointInput()
119         , m_queryLongResult(0)
120         , m_queryFloatResult(0.0f)
121         , m_queryPointResult()
122         , m_queryRectResult()
123         , m_stopProcessing(true)    
124         , m_atCharacter(0)
125     {
126     }
127
128     void chunkPortionCallback(SVGInlineTextBox* textBox, int startOffset, const TransformationMatrix&,
129                               const Vector<SVGChar>::iterator& start, const Vector<SVGChar>::iterator& end)
130     {
131         RenderStyle* style = textBox->textRenderer()->style();
132         bool isVerticalText = style->svgStyle()->writingMode() == WM_TBRL || style->svgStyle()->writingMode() == WM_TB;
133
134         switch (m_mode) {
135         case NumberOfCharacters:
136         {    
137             m_queryLongResult += (end - start);
138             m_stopProcessing = false;
139             return;
140         }
141         case TextLength:
142         {
143             float textLength = cumulativeCharacterRangeLength(start, end, textBox, startOffset, -1, -1, isVerticalText, m_atCharacter);
144
145             if (isVerticalText)
146                 m_queryFloatResult += textLength;
147             else
148                 m_queryFloatResult += textLength;
149
150             m_stopProcessing = false;
151             return;
152         }
153         case SubStringLength:
154         {
155             long startPosition = m_queryStartPosition;
156             long length = m_queryLength;
157
158             float textLength = cumulativeCharacterRangeLength(start, end, textBox, startOffset, startPosition, length, isVerticalText, m_atCharacter);
159
160             if (isVerticalText)
161                 m_queryFloatResult += textLength;
162             else
163                 m_queryFloatResult += textLength;
164
165             if (m_atCharacter == startPosition + length)
166                 m_stopProcessing = true;
167             else
168                 m_stopProcessing = false;
169
170             return;
171         }
172         case StartPosition:
173         {
174             for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
175                 if (m_atCharacter == m_queryStartPosition) {
176                     m_queryPointResult = FloatPoint(it->x, it->y);
177                     m_stopProcessing = true;
178                     return;
179                 }
180
181                 m_atCharacter++;
182             }
183
184             m_stopProcessing = false;
185             return;
186         }
187         case EndPosition:
188         {
189             for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
190                 if (m_atCharacter == m_queryStartPosition) {
191                     unsigned int newOffset = textBox->start() + (it - start) + startOffset;
192
193                     // Take RTL text into account and pick right glyph width/height.
194                     if (textBox->direction() == RTL)
195                         newOffset = textBox->start() + textBox->end() - newOffset;
196
197                     int charsConsumed;
198                     String glyphName;
199                     // calculateGlyph{Height,Width} will consume at least one character. This is the number of characters available
200                     // to them beyond that first one.
201                     int extraCharactersAvailable = end - it - 1;
202                     if (isVerticalText)
203                         m_queryPointResult.move(it->x, it->y + textBox->calculateGlyphHeight(style, newOffset, extraCharactersAvailable));
204                     else
205                         m_queryPointResult.move(it->x + textBox->calculateGlyphWidth(style, newOffset, extraCharactersAvailable, charsConsumed, glyphName), it->y);
206
207                     m_stopProcessing = true;
208                     return;
209                 }
210
211                 m_atCharacter++;
212             }
213
214             m_stopProcessing = false;
215             return;
216         }
217         case Extent:
218         {
219             for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
220                 if (m_atCharacter == m_queryStartPosition) {
221                     unsigned int newOffset = textBox->start() + (it - start) + startOffset;
222                     m_queryRectResult = textBox->calculateGlyphBoundaries(style, newOffset, *it);
223                     m_stopProcessing = true;
224                     return;
225                 }
226
227                 m_atCharacter++;
228             }
229
230             m_stopProcessing = false;
231             return;
232         }
233         case Rotation:
234         {
235             for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
236                 if (m_atCharacter == m_queryStartPosition) {
237                     m_queryFloatResult = it->angle;
238                     m_stopProcessing = true;
239                     return;
240                 }
241
242                 m_atCharacter++;
243             }
244
245             m_stopProcessing = false;
246             return;
247         }
248         case CharacterNumberAtPosition:
249         {
250             int offset = 0;
251             SVGChar* charAtPos = textBox->closestCharacterToPosition(m_queryPointInput.x(), m_queryPointInput.y(), offset);
252
253             offset += m_atCharacter;
254             if (charAtPos && offset > m_queryLongResult)
255                 m_queryLongResult = offset;
256
257             m_atCharacter += end - start;
258             m_stopProcessing = false;
259             return;
260         }
261         default:
262             ASSERT_NOT_REACHED();
263             m_stopProcessing = true;
264             return;
265         }
266     }
267
268     void setQueryInputParameters(long startPosition, long length, FloatPoint referencePoint)
269     {
270         m_queryStartPosition = startPosition;
271         m_queryLength = length;
272         m_queryPointInput = referencePoint;
273     }
274
275     long longResult() const { return m_queryLongResult; }
276     float floatResult() const { return m_queryFloatResult; }
277     FloatPoint pointResult() const { return m_queryPointResult; }
278     FloatRect rectResult() const { return m_queryRectResult; }
279     bool stopProcessing() const { return m_stopProcessing; }
280
281 private:
282     const SVGTextContentElement* m_reference;
283     QueryMode m_mode;
284
285     long m_queryStartPosition;
286     long m_queryLength;
287     FloatPoint m_queryPointInput;
288
289     long m_queryLongResult;
290     float m_queryFloatResult;
291     FloatPoint m_queryPointResult;
292     FloatRect m_queryRectResult;
293
294     bool m_stopProcessing;
295     long m_atCharacter;
296 };
297
298 static Vector<SVGInlineTextBox*> findInlineTextBoxInTextChunks(const SVGTextContentElement* element, const Vector<SVGTextChunk>& chunks)
299 {   
300     Vector<SVGTextChunk>::const_iterator it = chunks.begin();
301     const Vector<SVGTextChunk>::const_iterator end = chunks.end();
302
303     Vector<SVGInlineTextBox*> boxes;
304
305     for (; it != end; ++it) {
306         Vector<SVGInlineBoxCharacterRange>::const_iterator boxIt = it->boxes.begin();
307         const Vector<SVGInlineBoxCharacterRange>::const_iterator boxEnd = it->boxes.end();
308
309         for (; boxIt != boxEnd; ++boxIt) {
310             SVGInlineTextBox* textBox = static_cast<SVGInlineTextBox*>(boxIt->box);
311
312             Node* textElement = textBox->textRenderer()->parent()->node();
313             ASSERT(textElement);
314
315             if (textElement == element || textElement->parent() == element)
316                 boxes.append(textBox);
317         }
318     }
319
320     return boxes;
321 }
322
323 static inline SVGRootInlineBox* rootInlineBoxForTextContentElement(const SVGTextContentElement* element)
324 {
325     RenderObject* object = element->renderer();
326     
327     if (!object || !object->isSVGText() || object->isText())
328         return 0;
329
330     RenderSVGText* svgText = static_cast<RenderSVGText*>(object);
331
332     // Find root inline box
333     SVGRootInlineBox* rootBox = static_cast<SVGRootInlineBox*>(svgText->firstRootBox());
334     if (!rootBox) {
335         // Layout is not sync yet!
336         element->document()->updateLayoutIgnorePendingStylesheets();
337         rootBox = static_cast<SVGRootInlineBox*>(svgText->firstRootBox());
338     }
339
340     ASSERT(rootBox);
341     return rootBox;
342 }
343
344 static inline SVGInlineTextBoxQueryWalker executeTextQuery(const SVGTextContentElement* element, SVGInlineTextBoxQueryWalker::QueryMode mode,
345                                                            long startPosition = 0, long length = 0, FloatPoint referencePoint = FloatPoint())
346 {
347     SVGRootInlineBox* rootBox = rootInlineBoxForTextContentElement(element);
348     if (!rootBox)
349         return SVGInlineTextBoxQueryWalker(0, mode);
350
351     // Find all inline text box associated with our renderer
352     Vector<SVGInlineTextBox*> textBoxes = findInlineTextBoxInTextChunks(element, rootBox->svgTextChunks());
353
354     // Walk text chunks to find chunks associated with our inline text box
355     SVGInlineTextBoxQueryWalker walkerCallback(element, mode);
356     walkerCallback.setQueryInputParameters(startPosition, length, referencePoint);
357
358     SVGTextChunkWalker<SVGInlineTextBoxQueryWalker> walker(&walkerCallback, &SVGInlineTextBoxQueryWalker::chunkPortionCallback);
359
360     Vector<SVGInlineTextBox*>::iterator it = textBoxes.begin();
361     Vector<SVGInlineTextBox*>::iterator end = textBoxes.end();
362
363     for (; it != end; ++it) {
364         rootBox->walkTextChunks(&walker, *it);
365
366         if (walkerCallback.stopProcessing())
367             break;
368     }
369
370     return walkerCallback;
371 }
372
373 long SVGTextContentElement::getNumberOfChars() const
374 {
375     document()->updateLayoutIgnorePendingStylesheets();
376
377     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::NumberOfCharacters).longResult();
378 }
379
380 float SVGTextContentElement::getComputedTextLength() const
381 {
382     document()->updateLayoutIgnorePendingStylesheets();
383
384     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::TextLength).floatResult();
385 }
386
387 float SVGTextContentElement::getSubStringLength(long charnum, long nchars, ExceptionCode& ec) const
388 {
389     document()->updateLayoutIgnorePendingStylesheets();
390
391     long numberOfChars = getNumberOfChars();
392     if (charnum < 0 || nchars < 0 || charnum >= numberOfChars) {
393         ec = INDEX_SIZE_ERR;
394         return 0.0f;
395     }
396
397     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::SubStringLength, charnum, nchars).floatResult();
398 }
399
400 FloatPoint SVGTextContentElement::getStartPositionOfChar(long charnum, ExceptionCode& ec) const
401 {
402     document()->updateLayoutIgnorePendingStylesheets();
403
404     if (charnum < 0 || charnum > getNumberOfChars()) {
405         ec = INDEX_SIZE_ERR;
406         return FloatPoint();
407     }
408
409     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::StartPosition, charnum).pointResult();
410 }
411
412 FloatPoint SVGTextContentElement::getEndPositionOfChar(long charnum, ExceptionCode& ec) const
413 {
414     document()->updateLayoutIgnorePendingStylesheets();
415
416     if (charnum < 0 || charnum > getNumberOfChars()) {
417         ec = INDEX_SIZE_ERR;
418         return FloatPoint();
419     }
420
421     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::EndPosition, charnum).pointResult();
422 }
423
424 FloatRect SVGTextContentElement::getExtentOfChar(long charnum, ExceptionCode& ec) const
425 {
426     document()->updateLayoutIgnorePendingStylesheets();
427
428     if (charnum < 0 || charnum > getNumberOfChars()) {
429         ec = INDEX_SIZE_ERR;
430         return FloatRect();
431     }
432
433     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::Extent, charnum).rectResult();
434 }
435
436 float SVGTextContentElement::getRotationOfChar(long charnum, ExceptionCode& ec) const
437 {
438     document()->updateLayoutIgnorePendingStylesheets();
439
440     if (charnum < 0 || charnum > getNumberOfChars()) {
441         ec = INDEX_SIZE_ERR;
442         return 0.0f;
443     }
444
445     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::Rotation, charnum).floatResult();
446 }
447
448 long SVGTextContentElement::getCharNumAtPosition(const FloatPoint& point) const
449 {
450     document()->updateLayoutIgnorePendingStylesheets();
451
452     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::CharacterNumberAtPosition, 0.0f, 0.0f, point).longResult();
453 }
454
455 void SVGTextContentElement::selectSubString(long charnum, long nchars, ExceptionCode& ec) const
456 {
457     long numberOfChars = getNumberOfChars();
458     if (charnum < 0 || nchars < 0 || charnum >= numberOfChars) {
459         ec = INDEX_SIZE_ERR;
460         return;
461     }
462
463     if (nchars > numberOfChars - charnum)
464         nchars = numberOfChars - charnum;
465
466     ASSERT(document());
467     ASSERT(document()->frame());
468
469     SelectionController* controller = document()->frame()->selection();
470     if (!controller)
471         return;
472
473     // Find selection start
474     VisiblePosition start(const_cast<SVGTextContentElement*>(this), 0, SEL_DEFAULT_AFFINITY);
475     for (long i = 0; i < charnum; ++i)
476         start = start.next();
477
478     // Find selection end
479     VisiblePosition end(start);
480     for (long i = 0; i < nchars; ++i)
481         end = end.next();
482
483     controller->setSelection(VisibleSelection(start, end));
484 }
485
486 void SVGTextContentElement::parseMappedAttribute(MappedAttribute* attr)
487 {
488     if (attr->name() == SVGNames::lengthAdjustAttr) {
489         if (attr->value() == "spacing")
490             setLengthAdjustBaseValue(LENGTHADJUST_SPACING);
491         else if (attr->value() == "spacingAndGlyphs")
492             setLengthAdjustBaseValue(LENGTHADJUST_SPACINGANDGLYPHS);
493     } else if (attr->name() == SVGNames::textLengthAttr) {
494         setTextLengthBaseValue(SVGLength(LengthModeOther, attr->value()));
495         if (textLengthBaseValue().value(this) < 0.0)
496             document()->accessSVGExtensions()->reportError("A negative value for text attribute <textLength> is not allowed");
497     } else {
498         if (SVGTests::parseMappedAttribute(attr))
499             return;
500         if (SVGLangSpace::parseMappedAttribute(attr)) {
501             if (attr->name().matches(XMLNames::spaceAttr)) {
502                 DEFINE_STATIC_LOCAL(const AtomicString, preserveString, ("preserve"));
503
504                 if (attr->value() == preserveString)
505                     addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValuePre);
506                 else
507                     addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValueNowrap);
508             }
509             return;
510         }
511         if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
512             return;
513
514         SVGStyledElement::parseMappedAttribute(attr);
515     }
516 }
517
518 bool SVGTextContentElement::isKnownAttribute(const QualifiedName& attrName)
519 {
520     return (attrName.matches(SVGNames::lengthAdjustAttr) ||
521             attrName.matches(SVGNames::textLengthAttr) ||
522             SVGTests::isKnownAttribute(attrName) ||
523             SVGLangSpace::isKnownAttribute(attrName) ||
524             SVGExternalResourcesRequired::isKnownAttribute(attrName) ||
525             SVGStyledElement::isKnownAttribute(attrName));
526 }
527
528 }
529
530 #endif // ENABLE(SVG)