WebCore:
[WebKit.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
42 namespace WebCore {
43
44 SVGTextContentElement::SVGTextContentElement(const QualifiedName& tagName, Document* doc)
45     : SVGStyledElement(tagName, doc)
46     , SVGTests()
47     , SVGLangSpace()
48     , SVGExternalResourcesRequired()
49     , m_textLength(this, LengthModeOther)
50     , m_lengthAdjust(LENGTHADJUST_SPACING)
51 {
52 }
53
54 SVGTextContentElement::~SVGTextContentElement()
55 {
56 }
57
58 ANIMATED_PROPERTY_DEFINITIONS(SVGTextContentElement, SVGLength, Length, length, TextLength, textLength, SVGNames::textLengthAttr, m_textLength)
59 ANIMATED_PROPERTY_DEFINITIONS(SVGTextContentElement, int, Enumeration, enumeration, LengthAdjust, lengthAdjust, SVGNames::lengthAdjustAttr, m_lengthAdjust)
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->textObject()->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 AffineTransform& chunkCtm,
129                               const Vector<SVGChar>::iterator& start, const Vector<SVGChar>::iterator& end)
130     {
131         RenderStyle* style = textBox->textObject()->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                     if (isVerticalText)
200                         m_queryPointResult.move(it->x, it->y + textBox->calculateGlyphHeight(style, newOffset, end - it));
201                     else
202                         m_queryPointResult.move(it->x + textBox->calculateGlyphWidth(style, newOffset, end - it, charsConsumed, glyphName), it->y);
203
204                     m_stopProcessing = true;
205                     return;
206                 }
207
208                 m_atCharacter++;
209             }
210
211             m_stopProcessing = false;
212             return;
213         }
214         case Extent:
215         {
216             for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
217                 if (m_atCharacter == m_queryStartPosition) {
218                     unsigned int newOffset = textBox->start() + (it - start) + startOffset;
219                     m_queryRectResult = textBox->calculateGlyphBoundaries(style, newOffset, *it);
220                     m_stopProcessing = true;
221                     return;
222                 }
223
224                 m_atCharacter++;
225             }
226
227             m_stopProcessing = false;
228             return;
229         }
230         case Rotation:
231         {
232             for (Vector<SVGChar>::iterator it = start; it != end; ++it) {
233                 if (m_atCharacter == m_queryStartPosition) {
234                     m_queryFloatResult = it->angle;
235                     m_stopProcessing = true;
236                     return;
237                 }
238
239                 m_atCharacter++;
240             }
241
242             m_stopProcessing = false;
243             return;
244         }
245         case CharacterNumberAtPosition:
246         {
247             int offset = 0;
248             SVGChar* charAtPos = textBox->closestCharacterToPosition(m_queryPointInput.x(), m_queryPointInput.y(), offset);
249
250             offset += m_atCharacter;
251             if (charAtPos && offset > m_queryLongResult)
252                 m_queryLongResult = offset;
253
254             m_atCharacter += end - start;
255             m_stopProcessing = false;
256             return;
257         }
258         default:
259             ASSERT_NOT_REACHED();
260             m_stopProcessing = true;
261             return;
262         }
263     }
264
265     void setQueryInputParameters(long startPosition, long length, FloatPoint referencePoint)
266     {
267         m_queryStartPosition = startPosition;
268         m_queryLength = length;
269         m_queryPointInput = referencePoint;
270     }
271
272     long longResult() const { return m_queryLongResult; }
273     float floatResult() const { return m_queryFloatResult; }
274     FloatPoint pointResult() const { return m_queryPointResult; }
275     FloatRect rectResult() const { return m_queryRectResult; }
276     bool stopProcessing() const { return m_stopProcessing; }
277
278 private:
279     const SVGTextContentElement* m_reference;
280     QueryMode m_mode;
281
282     long m_queryStartPosition;
283     long m_queryLength;
284     FloatPoint m_queryPointInput;
285
286     long m_queryLongResult;
287     float m_queryFloatResult;
288     FloatPoint m_queryPointResult;
289     FloatRect m_queryRectResult;
290
291     bool m_stopProcessing;
292     long m_atCharacter;
293 };
294
295 static Vector<SVGInlineTextBox*> findInlineTextBoxInTextChunks(const SVGTextContentElement* element, const Vector<SVGTextChunk>& chunks)
296 {   
297     Vector<SVGTextChunk>::const_iterator it = chunks.begin();
298     const Vector<SVGTextChunk>::const_iterator end = chunks.end();
299
300     Vector<SVGInlineTextBox*> boxes;
301
302     for (; it != end; ++it) {
303         Vector<SVGInlineBoxCharacterRange>::const_iterator boxIt = it->boxes.begin();
304         const Vector<SVGInlineBoxCharacterRange>::const_iterator boxEnd = it->boxes.end();
305
306         for (; boxIt != boxEnd; ++boxIt) {
307             SVGInlineTextBox* textBox = static_cast<SVGInlineTextBox*>(boxIt->box);
308
309             Node* textElement = textBox->textObject()->parent()->element();
310             ASSERT(textElement);
311
312             if (textElement == element || textElement->parent() == element)
313                 boxes.append(textBox);
314         }
315     }
316
317     return boxes;
318 }
319
320 static inline SVGRootInlineBox* rootInlineBoxForTextContentElement(const SVGTextContentElement* element)
321 {
322     RenderObject* object = element->renderer();
323     
324     if (!object || !object->isSVGText() || object->isText())
325         return 0;
326
327     RenderSVGText* svgText = static_cast<RenderSVGText*>(object);
328
329     // Find root inline box
330     SVGRootInlineBox* rootBox = static_cast<SVGRootInlineBox*>(svgText->firstRootBox());
331     if (!rootBox) {
332         // Layout is not sync yet!
333         element->document()->updateLayoutIgnorePendingStylesheets();
334         rootBox = static_cast<SVGRootInlineBox*>(svgText->firstRootBox());
335     }
336
337     ASSERT(rootBox);
338     return rootBox;
339 }
340
341 static inline SVGInlineTextBoxQueryWalker executeTextQuery(const SVGTextContentElement* element, SVGInlineTextBoxQueryWalker::QueryMode mode,
342                                                            long startPosition = 0, long length = 0, FloatPoint referencePoint = FloatPoint())
343 {
344     SVGRootInlineBox* rootBox = rootInlineBoxForTextContentElement(element);
345     if (!rootBox)
346         return SVGInlineTextBoxQueryWalker(0, mode);
347
348     // Find all inline text box associated with our renderer
349     Vector<SVGInlineTextBox*> textBoxes = findInlineTextBoxInTextChunks(element, rootBox->svgTextChunks());
350
351     // Walk text chunks to find chunks associated with our inline text box
352     SVGInlineTextBoxQueryWalker walkerCallback(element, mode);
353     walkerCallback.setQueryInputParameters(startPosition, length, referencePoint);
354
355     SVGTextChunkWalker<SVGInlineTextBoxQueryWalker> walker(&walkerCallback, &SVGInlineTextBoxQueryWalker::chunkPortionCallback);
356
357     Vector<SVGInlineTextBox*>::iterator it = textBoxes.begin();
358     Vector<SVGInlineTextBox*>::iterator end = textBoxes.end();
359
360     for (; it != end; ++it) {
361         rootBox->walkTextChunks(&walker, *it);
362
363         if (walkerCallback.stopProcessing())
364             break;
365     }
366
367     return walkerCallback;
368 }
369
370 long SVGTextContentElement::getNumberOfChars() const
371 {
372     document()->updateLayoutIgnorePendingStylesheets();
373
374     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::NumberOfCharacters).longResult();
375 }
376
377 float SVGTextContentElement::getComputedTextLength() const
378 {
379     document()->updateLayoutIgnorePendingStylesheets();
380
381     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::TextLength).floatResult();
382 }
383
384 float SVGTextContentElement::getSubStringLength(long charnum, long nchars, ExceptionCode& ec) const
385 {
386     document()->updateLayoutIgnorePendingStylesheets();
387
388     // Differences to SVG 1.1 spec, as the spec is clearly wrong. TODO: Raise SVG WG issue!
389     // #1: We accept a 'long nchars' parameter instead of 'unsigned long nchars' to be able
390     //     to catch cases where someone called us with a negative 'nchars' value - in those
391     //     cases we'll just throw a 'INDEX_SIZE_ERR' (acid3 implicitly agrees with us)
392     //
393     // #2: We only throw if 'charnum + nchars' is greater than the number of characters, not
394     //     if it's equal, as this really doesn't make any sense (no way to measure the last character!)
395     //
396     // #3: If 'charnum' is greater than or equal to 'numberOfChars', we're throwing an exception here
397     //     as the result is undefined for every other value of 'nchars' than '0'.
398
399     long numberOfChars = getNumberOfChars();
400     if (charnum < 0 || nchars < 0 || numberOfChars <= charnum || charnum + nchars > numberOfChars) {
401         ec = INDEX_SIZE_ERR;
402         return 0.0f;
403     }
404
405     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::SubStringLength, charnum, nchars).floatResult();
406 }
407
408 FloatPoint SVGTextContentElement::getStartPositionOfChar(long charnum, ExceptionCode& ec) const
409 {
410     document()->updateLayoutIgnorePendingStylesheets();
411
412     if (charnum < 0 || charnum > getNumberOfChars()) {
413         ec = INDEX_SIZE_ERR;
414         return FloatPoint();
415     }
416
417     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::StartPosition, charnum).pointResult();
418 }
419
420 FloatPoint SVGTextContentElement::getEndPositionOfChar(long charnum, ExceptionCode& ec) const
421 {
422     document()->updateLayoutIgnorePendingStylesheets();
423
424     if (charnum < 0 || charnum > getNumberOfChars()) {
425         ec = INDEX_SIZE_ERR;
426         return FloatPoint();
427     }
428
429     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::EndPosition, charnum).pointResult();
430 }
431
432 FloatRect SVGTextContentElement::getExtentOfChar(long charnum, ExceptionCode& ec) const
433 {
434     document()->updateLayoutIgnorePendingStylesheets();
435
436     if (charnum < 0 || charnum > getNumberOfChars()) {
437         ec = INDEX_SIZE_ERR;
438         return FloatRect();
439     }
440
441     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::Extent, charnum).rectResult();
442 }
443
444 float SVGTextContentElement::getRotationOfChar(long charnum, ExceptionCode& ec) const
445 {
446     document()->updateLayoutIgnorePendingStylesheets();
447
448     if (charnum < 0 || charnum > getNumberOfChars()) {
449         ec = INDEX_SIZE_ERR;
450         return 0.0f;
451     }
452
453     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::Rotation, charnum).floatResult();
454 }
455
456 long SVGTextContentElement::getCharNumAtPosition(const FloatPoint& point) const
457 {
458     document()->updateLayoutIgnorePendingStylesheets();
459
460     return executeTextQuery(this, SVGInlineTextBoxQueryWalker::CharacterNumberAtPosition, 0.0f, 0.0f, point).longResult();
461 }
462
463 void SVGTextContentElement::selectSubString(long charnum, long nchars, ExceptionCode& ec) const
464 {
465     long numberOfChars = getNumberOfChars();
466     if (charnum < 0 || nchars < 0 || charnum > numberOfChars) {
467         ec = INDEX_SIZE_ERR;
468         return;
469     }
470
471     if (nchars > numberOfChars - charnum)
472         nchars = numberOfChars - charnum;
473
474     ASSERT(document());
475     ASSERT(document()->frame());
476
477     SelectionController* controller = document()->frame()->selectionController();
478     if (!controller)
479         return;
480
481     // Find selection start
482     VisiblePosition start(const_cast<SVGTextContentElement*>(this), 0, SEL_DEFAULT_AFFINITY);
483     for (long i = 0; i < charnum; ++i)
484         start = start.next();
485
486     // Find selection end
487     VisiblePosition end(start);
488     for (long i = 0; i < nchars; ++i)
489         end = end.next();
490
491     controller->setSelection(Selection(start, end));
492 }
493
494 void SVGTextContentElement::parseMappedAttribute(MappedAttribute* attr)
495 {
496     if (attr->name() == SVGNames::lengthAdjustAttr) {
497         if (attr->value() == "spacing")
498             setLengthAdjustBaseValue(LENGTHADJUST_SPACING);
499         else if (attr->value() == "spacingAndGlyphs")
500             setLengthAdjustBaseValue(LENGTHADJUST_SPACINGANDGLYPHS);
501     } else if (attr->name() == SVGNames::textLengthAttr) {
502         setTextLengthBaseValue(SVGLength(this, LengthModeOther, attr->value()));
503         if (textLength().value() < 0.0)
504             document()->accessSVGExtensions()->reportError("A negative value for text attribute <textLength> is not allowed");
505     } else {
506         if (SVGTests::parseMappedAttribute(attr))
507             return;
508         if (SVGLangSpace::parseMappedAttribute(attr)) {
509             if (attr->name().matches(XMLNames::spaceAttr)) {
510                 static const AtomicString preserveString("preserve");
511
512                 if (attr->value() == preserveString)
513                     addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValuePre);
514                 else
515                     addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValueNowrap);
516             }
517             return;
518         }
519         if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
520             return;
521
522         SVGStyledElement::parseMappedAttribute(attr);
523     }
524 }
525
526 bool SVGTextContentElement::isKnownAttribute(const QualifiedName& attrName)
527 {
528     return (attrName.matches(SVGNames::lengthAdjustAttr) ||
529             attrName.matches(SVGNames::textLengthAttr) ||
530             SVGTests::isKnownAttribute(attrName) ||
531             SVGLangSpace::isKnownAttribute(attrName) ||
532             SVGExternalResourcesRequired::isKnownAttribute(attrName) ||
533             SVGStyledElement::isKnownAttribute(attrName));
534 }
535
536 }
537
538 #endif // ENABLE(SVG)