ca7790b8c2800ddfe9bbc23a4a3f9cae5b8cf4ba
[WebKit-https.git] / Source / WebCore / rendering / RenderRuby.cpp
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32
33 #include "RenderRuby.h"
34
35 #include "RenderRubyRun.h"
36 #include "RenderStyle.h"
37 #include "StyleInheritedData.h"
38 #include <wtf/RefPtr.h>
39
40 namespace WebCore {
41
42 //=== generic helper functions to avoid excessive code duplication ===
43
44 static inline bool isAnonymousRubyInlineBlock(const RenderObject* object)
45 {
46     ASSERT(!object
47         || !object->parent()->isRuby()
48         || object->isRubyRun()
49         || (object->isInline() && (object->isBeforeContent() || object->isAfterContent()))
50         || (object->isAnonymous() && object->isRenderBlock() && object->style()->display() == INLINE_BLOCK));
51
52     return object
53         && object->parent()->isRuby()
54         && object->isRenderBlock()
55         && !object->isRubyRun();
56 }
57
58 static inline bool isRubyBeforeBlock(const RenderObject* object)
59 {
60     return isAnonymousRubyInlineBlock(object)
61         && !object->previousSibling()
62         && object->firstChild()
63         && object->firstChild()->style()->styleType() == BEFORE;
64 }
65
66 static inline bool isRubyAfterBlock(const RenderObject* object)
67 {
68     return isAnonymousRubyInlineBlock(object)
69         && !object->nextSibling()
70         && object->firstChild()
71         && object->firstChild()->style()->styleType() == AFTER;
72 }
73
74 static inline RenderBlock* rubyBeforeBlock(const RenderObject* ruby)
75 {
76     RenderObject* child = ruby->firstChild();
77     return isRubyBeforeBlock(child) ? toRenderBlock(child) : 0;
78 }
79
80 static inline RenderBlock* rubyAfterBlock(const RenderObject* ruby)
81 {
82     RenderObject* child = ruby->lastChild();
83     return isRubyAfterBlock(child) ? toRenderBlock(child) : 0;
84 }
85
86 static RenderBlock* createAnonymousRubyInlineBlock(RenderObject* ruby)
87 {
88     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(ruby->style(), INLINE_BLOCK);
89     RenderBlock* newBlock = RenderBlock::createAnonymous(&ruby->document());
90     newBlock->setStyle(newStyle.release());
91     return newBlock;
92 }
93
94 static RenderRubyRun* lastRubyRun(const RenderObject* ruby)
95 {
96     RenderObject* child = ruby->lastChild();
97     if (child && !child->isRubyRun())
98         child = child->previousSibling();
99     ASSERT(!child || child->isRubyRun() || child->isBeforeContent() || child == rubyBeforeBlock(ruby));
100     return child && child->isRubyRun() ? toRenderRubyRun(child) : 0;
101 }
102
103 static inline RenderRubyRun* findRubyRunParent(RenderObject* child)
104 {
105     while (child && !child->isRubyRun())
106         child = child->parent();
107     return toRenderRubyRun(child);
108 }
109
110 //=== ruby as inline object ===
111
112 RenderRubyAsInline::RenderRubyAsInline(Element& element)
113     : RenderInline(&element)
114 {
115 }
116
117 RenderRubyAsInline::~RenderRubyAsInline()
118 {
119 }
120
121 void RenderRubyAsInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
122 {
123     RenderInline::styleDidChange(diff, oldStyle);
124     propagateStyleToAnonymousChildren();
125 }
126
127 void RenderRubyAsInline::addChild(RenderObject* child, RenderObject* beforeChild)
128 {
129     // Insert :before and :after content before/after the RenderRubyRun(s)
130     if (child->isBeforeContent()) {
131         if (child->isInline()) {
132             // Add generated inline content normally
133             RenderInline::addChild(child, firstChild());
134         } else {
135             // Wrap non-inline content with an anonymous inline-block.
136             RenderBlock* beforeBlock = rubyBeforeBlock(this);
137             if (!beforeBlock) {
138                 beforeBlock = createAnonymousRubyInlineBlock(this);
139                 RenderInline::addChild(beforeBlock, firstChild());
140             }
141             beforeBlock->addChild(child);
142         }
143         return;
144     }
145     if (child->isAfterContent()) {
146         if (child->isInline()) {
147             // Add generated inline content normally
148             RenderInline::addChild(child);
149         } else {
150             // Wrap non-inline content with an anonymous inline-block.
151             RenderBlock* afterBlock = rubyAfterBlock(this);
152             if (!afterBlock) {
153                 afterBlock = createAnonymousRubyInlineBlock(this);
154                 RenderInline::addChild(afterBlock);
155             }
156             afterBlock->addChild(child);
157         }
158         return;
159     }
160
161     // If the child is a ruby run, just add it normally.
162     if (child->isRubyRun()) {
163         RenderInline::addChild(child, beforeChild);
164         return;
165     }
166
167     if (beforeChild && !isAfterContent(beforeChild)) {
168         // insert child into run
169         ASSERT(!beforeChild->isRubyRun());
170         RenderObject* run = beforeChild;
171         while (run && !run->isRubyRun())
172             run = run->parent();
173         if (run) {
174             run->addChild(child, beforeChild);
175             return;
176         }
177         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
178         // Emergency fallback: fall through and just append.
179     }
180
181     // If the new child would be appended, try to add the child to the previous run
182     // if possible, or create a new run otherwise.
183     // (The RenderRubyRun object will handle the details)
184     RenderRubyRun* lastRun = lastRubyRun(this);
185     if (!lastRun || lastRun->hasRubyText()) {
186         lastRun = RenderRubyRun::staticCreateRubyRun(this);
187         RenderInline::addChild(lastRun, beforeChild);
188     }
189     lastRun->addChild(child);
190 }
191
192 void RenderRubyAsInline::removeChild(RenderObject* child)
193 {
194     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
195     // just use the normal remove method.
196     if (child->parent() == this) {
197         ASSERT(child->isRubyRun() || child->isBeforeContent() || child->isAfterContent() || isAnonymousRubyInlineBlock(child));
198         RenderInline::removeChild(child);
199         return;
200     }
201     // If the child's parent is an anoymous block (must be generated :before/:after content)
202     // just use the block's remove method.
203     if (isAnonymousRubyInlineBlock(child->parent())) {
204         ASSERT(child->isBeforeContent() || child->isAfterContent());
205         child->parent()->removeChild(child);
206         removeChild(child->parent());
207         return;
208     }
209
210     // Otherwise find the containing run and remove it from there.
211     RenderRubyRun* run = findRubyRunParent(child);
212     ASSERT(run);
213     run->removeChild(child);
214 }
215
216 //=== ruby as block object ===
217
218 RenderRubyAsBlock::RenderRubyAsBlock(Element& element)
219     : RenderBlockFlow(&element)
220 {
221 }
222
223 RenderRubyAsBlock::~RenderRubyAsBlock()
224 {
225 }
226
227 void RenderRubyAsBlock::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
228 {
229     RenderBlock::styleDidChange(diff, oldStyle);
230     propagateStyleToAnonymousChildren();
231 }
232
233 void RenderRubyAsBlock::addChild(RenderObject* child, RenderObject* beforeChild)
234 {
235     // Insert :before and :after content before/after the RenderRubyRun(s)
236     if (child->isBeforeContent()) {
237         if (child->isInline()) {
238             // Add generated inline content normally
239             RenderBlock::addChild(child, firstChild());
240         } else {
241             // Wrap non-inline content with an anonymous inline-block.
242             RenderBlock* beforeBlock = rubyBeforeBlock(this);
243             if (!beforeBlock) {
244                 beforeBlock = createAnonymousRubyInlineBlock(this);
245                 RenderBlock::addChild(beforeBlock, firstChild());
246             }
247             beforeBlock->addChild(child);
248         }
249         return;
250     }
251     if (child->isAfterContent()) {
252         if (child->isInline()) {
253             // Add generated inline content normally
254             RenderBlock::addChild(child);
255         } else {
256             // Wrap non-inline content with an anonymous inline-block.
257             RenderBlock* afterBlock = rubyAfterBlock(this);
258             if (!afterBlock) {
259                 afterBlock = createAnonymousRubyInlineBlock(this);
260                 RenderBlock::addChild(afterBlock);
261             }
262             afterBlock->addChild(child);
263         }
264         return;
265     }
266
267     // If the child is a ruby run, just add it normally.
268     if (child->isRubyRun()) {
269         RenderBlock::addChild(child, beforeChild);
270         return;
271     }
272
273     if (beforeChild && !isAfterContent(beforeChild)) {
274         // insert child into run
275         ASSERT(!beforeChild->isRubyRun());
276         RenderObject* run = beforeChild;
277         while (run && !run->isRubyRun())
278             run = run->parent();
279         if (run) {
280             run->addChild(child, beforeChild);
281             return;
282         }
283         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
284         // Emergency fallback: fall through and just append.
285     }
286
287     // If the new child would be appended, try to add the child to the previous run
288     // if possible, or create a new run otherwise.
289     // (The RenderRubyRun object will handle the details)
290     RenderRubyRun* lastRun = lastRubyRun(this);
291     if (!lastRun || lastRun->hasRubyText()) {
292         lastRun = RenderRubyRun::staticCreateRubyRun(this);
293         RenderBlock::addChild(lastRun, beforeChild);
294     }
295     lastRun->addChild(child);
296 }
297
298 void RenderRubyAsBlock::removeChild(RenderObject* child)
299 {
300     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
301     // just use the normal remove method.
302     if (child->parent() == this) {
303         ASSERT(child->isRubyRun() || child->isBeforeContent() || child->isAfterContent() || isAnonymousRubyInlineBlock(child));
304         RenderBlock::removeChild(child);
305         return;
306     }
307     // If the child's parent is an anoymous block (must be generated :before/:after content)
308     // just use the block's remove method.
309     if (isAnonymousRubyInlineBlock(child->parent())) {
310         ASSERT(child->isBeforeContent() || child->isAfterContent());
311         child->parent()->removeChild(child);
312         removeChild(child->parent());
313         return;
314     }
315
316     // Otherwise find the containing run and remove it from there.
317     RenderRubyRun* run = findRubyRunParent(child);
318     ASSERT(run);
319     run->removeChild(child);
320 }
321
322 } // namespace WebCore