0dee63715755f6523118f10bf1d3a12c16154566
[WebKit.git] / Source / WebCore / rendering / RenderRubyRun.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 "RenderRubyRun.h"
34
35 #include "RenderRubyBase.h"
36 #include "RenderRubyText.h"
37 #include "RenderText.h"
38 #include "RenderView.h"
39
40 using namespace std;
41
42 namespace WebCore {
43
44 RenderRubyRun::RenderRubyRun(Node* node)
45     : RenderBlock(node)
46 {
47     setReplaced(true);
48     setInline(true);
49 }
50
51 RenderRubyRun::~RenderRubyRun()
52 {
53 }
54
55 bool RenderRubyRun::hasRubyText() const
56 {
57     // The only place where a ruby text can be is in the first position
58     // Note: As anonymous blocks, ruby runs do not have ':before' or ':after' content themselves.
59     return firstChild() && firstChild()->isRubyText();
60 }
61
62 bool RenderRubyRun::hasRubyBase() const
63 {
64     // The only place where a ruby base can be is in the last position
65     // Note: As anonymous blocks, ruby runs do not have ':before' or ':after' content themselves.
66     return lastChild() && lastChild()->isRubyBase();
67 }
68
69 bool RenderRubyRun::isEmpty() const
70 {
71     return !hasRubyText() && !hasRubyBase();
72 }
73
74 RenderRubyText* RenderRubyRun::rubyText() const
75 {
76     RenderObject* child = firstChild();
77     return child && child->isRubyText() ? static_cast<RenderRubyText*>(child) : 0;
78 }
79
80 RenderRubyBase* RenderRubyRun::rubyBase() const
81 {
82     RenderObject* child = lastChild();
83     return child && child->isRubyBase() ? static_cast<RenderRubyBase*>(child) : 0;
84 }
85
86 RenderRubyBase* RenderRubyRun::rubyBaseSafe()
87 {
88     RenderRubyBase* base = rubyBase();
89     if (!base) {
90         base = createRubyBase();
91         RenderBlock::addChild(base);
92     }
93     return base;
94 }
95
96 RenderBlock* RenderRubyRun::firstLineBlock() const
97 {
98     return 0;
99 }
100
101 void RenderRubyRun::updateFirstLetter()
102 {
103 }
104
105 bool RenderRubyRun::isChildAllowed(RenderObject* child, RenderStyle*) const
106 {
107     return child->isRubyText() || child->isInline();
108 }
109
110 void RenderRubyRun::addChild(RenderObject* child, RenderObject* beforeChild)
111 {
112     ASSERT(child);
113
114     if (child->isRubyText()) {
115         if (!beforeChild) {
116             // RenderRuby has already ascertained that we can add the child here.
117             ASSERT(!hasRubyText());
118             // prepend ruby texts as first child
119             RenderBlock::addChild(child, firstChild());
120         }  else if (beforeChild->isRubyText()) {
121             // New text is inserted just before another.
122             // In this case the new text takes the place of the old one, and
123             // the old text goes into a new run that is inserted as next sibling.
124             ASSERT(beforeChild->parent() == this);
125             RenderObject* ruby = parent();
126             ASSERT(ruby->isRuby());
127             RenderBlock* newRun = staticCreateRubyRun(ruby);
128             ruby->addChild(newRun, nextSibling());
129             // Add the new ruby text and move the old one to the new run
130             // Note: Doing it in this order and not using RenderRubyRun's methods,
131             // in order to avoid automatic removal of the ruby run in case there is no
132             // other child besides the old ruby text.
133             RenderBlock::addChild(child, beforeChild);
134             RenderBlock::removeChild(beforeChild);
135             newRun->addChild(beforeChild);
136         } else if (hasRubyBase()) {
137             // Insertion before a ruby base object.
138             // In this case we need insert a new run before the current one and split the base.
139             RenderObject* ruby = parent();
140             RenderRubyRun* newRun = staticCreateRubyRun(ruby);
141             ruby->addChild(newRun, this);
142             newRun->addChild(child);
143             rubyBaseSafe()->moveChildren(newRun->rubyBaseSafe(), beforeChild);
144         }
145     } else {
146         // child is not a text -> insert it into the base
147         // (append it instead if beforeChild is the ruby text)
148         if (beforeChild && beforeChild->isRubyText())
149             beforeChild = 0;
150         rubyBaseSafe()->addChild(child, beforeChild);
151     }
152 }
153
154 void RenderRubyRun::removeChild(RenderObject* child)
155 {
156     // If the child is a ruby text, then merge the ruby base with the base of
157     // the right sibling run, if possible.
158     if (!beingDestroyed() && !documentBeingDestroyed() && child->isRubyText()) {
159         RenderRubyBase* base = rubyBase();
160         RenderObject* rightNeighbour = nextSibling();
161         if (base && rightNeighbour && rightNeighbour->isRubyRun()) {
162             // Ruby run without a base can happen only at the first run.
163             RenderRubyRun* rightRun = toRenderRubyRun(rightNeighbour);
164             if (rightRun->hasRubyBase()) {
165                 RenderRubyBase* rightBase = rightRun->rubyBaseSafe();
166                 // Collect all children in a single base, then swap the bases.
167                 rightBase->moveChildren(base);
168                 moveChildTo(rightRun, base);
169                 rightRun->moveChildTo(this, rightBase);
170                 // The now empty ruby base will be removed below.
171             }
172         }
173     }
174
175     RenderBlock::removeChild(child);
176
177     if (!beingDestroyed() && !documentBeingDestroyed()) {
178         // Check if our base (if any) is now empty. If so, destroy it.
179         RenderBlock* base = rubyBase();
180         if (base && !base->firstChild()) {
181             RenderBlock::removeChild(base);
182             base->deleteLineBoxTree();
183             base->destroy();
184         }
185
186         // If any of the above leaves the run empty, destroy it as well.
187         if (isEmpty()) {
188             parent()->removeChild(this);
189             deleteLineBoxTree();
190             destroy();
191         }
192     }
193 }
194
195 RenderRubyBase* RenderRubyRun::createRubyBase() const
196 {
197     RenderRubyBase* rb = new (renderArena()) RenderRubyBase(document() /* anonymous */);
198     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyle(style());
199     newStyle->setDisplay(BLOCK);
200     newStyle->setTextAlign(CENTER); // FIXME: use WEBKIT_CENTER?
201     rb->setStyle(newStyle.release());
202     return rb;
203 }
204
205 RenderRubyRun* RenderRubyRun::staticCreateRubyRun(const RenderObject* parentRuby)
206 {
207     ASSERT(parentRuby && parentRuby->isRuby());
208     RenderRubyRun* rr = new (parentRuby->renderArena()) RenderRubyRun(parentRuby->document() /* anonymous */);
209     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyle(parentRuby->style());
210     newStyle->setDisplay(INLINE_BLOCK);
211     rr->setStyle(newStyle.release());
212     return rr;
213 }
214
215 RenderObject* RenderRubyRun::layoutSpecialExcludedChild(bool relayoutChildren)
216 {
217     // Don't bother positioning the RenderRubyRun yet.
218     RenderRubyText* rt = rubyText();
219     if (!rt)
220         return 0;
221     if (relayoutChildren)
222         rt->setChildNeedsLayout(true, false);
223     rt->layoutIfNeeded();
224     return rt;
225 }
226
227 void RenderRubyRun::layout()
228 {
229     RenderBlock::layout();
230     
231     // Place the RenderRubyText such that its bottom is flush with the lineTop of the first line of the RenderRubyBase.
232     RenderRubyText* rt = rubyText();
233     if (!rt)
234         return;
235     
236     LayoutUnit lastLineRubyTextBottom = rt->logicalHeight();
237     LayoutUnit firstLineRubyTextTop = 0;
238     RootInlineBox* rootBox = rt->lastRootBox();
239     if (rootBox) {
240         // In order to align, we have to ignore negative leading.
241         firstLineRubyTextTop = rt->firstRootBox()->logicalTopLayoutOverflow();
242         lastLineRubyTextBottom = rootBox->logicalBottomLayoutOverflow();
243     }
244
245     if (!style()->isFlippedLinesWritingMode()) {
246         LayoutUnit firstLineTop = 0;
247         if (RenderRubyBase* rb = rubyBase()) {
248             RootInlineBox* rootBox = rb->firstRootBox();
249             if (rootBox)
250                 firstLineTop = rootBox->logicalTopLayoutOverflow();
251             firstLineTop += rb->logicalTop();
252         }
253         
254         rt->setLogicalTop(-lastLineRubyTextBottom + firstLineTop);
255     } else {
256         LayoutUnit lastLineBottom = logicalHeight();
257         if (RenderRubyBase* rb = rubyBase()) {
258             RootInlineBox* rootBox = rb->lastRootBox();
259             if (rootBox)
260                 lastLineBottom = rootBox->logicalBottomLayoutOverflow();
261             lastLineBottom += rb->logicalTop();
262         }
263
264         rt->setLogicalTop(-firstLineRubyTextTop + lastLineBottom);
265     }
266
267     // Update our overflow to account for the new RenderRubyText position.
268     m_overflow.clear();
269     computeOverflow(clientLogicalBottom());
270 }
271
272 void RenderRubyRun::getOverhang(bool firstLine, RenderObject* startRenderer, RenderObject* endRenderer, int& startOverhang, int& endOverhang) const
273 {
274     ASSERT(!needsLayout());
275
276     startOverhang = 0;
277     endOverhang = 0;
278
279     RenderRubyBase* rubyBase = this->rubyBase();
280     RenderRubyText* rubyText = this->rubyText();
281
282     if (!rubyBase || !rubyText)
283         return;
284
285     if (!rubyBase->firstRootBox())
286         return;
287
288     int logicalWidth = this->logicalWidth();
289     int logicalLeftOverhang = numeric_limits<int>::max();
290     int logicalRightOverhang = numeric_limits<int>::max();
291     for (RootInlineBox* rootInlineBox = rubyBase->firstRootBox(); rootInlineBox; rootInlineBox = rootInlineBox->nextRootBox()) {
292         logicalLeftOverhang = min<int>(logicalLeftOverhang, rootInlineBox->logicalLeft());
293         logicalRightOverhang = min<int>(logicalRightOverhang, logicalWidth - rootInlineBox->logicalRight());
294     }
295
296     startOverhang = style()->isLeftToRightDirection() ? logicalLeftOverhang : logicalRightOverhang;
297     endOverhang = style()->isLeftToRightDirection() ? logicalRightOverhang : logicalLeftOverhang;
298
299     if (!startRenderer || !startRenderer->isText() || startRenderer->style(firstLine)->fontSize() > rubyBase->style(firstLine)->fontSize())
300         startOverhang = 0;
301
302     if (!endRenderer || !endRenderer->isText() || endRenderer->style(firstLine)->fontSize() > rubyBase->style(firstLine)->fontSize())
303         endOverhang = 0;
304
305     // We overhang a ruby only if the neighboring render object is a text.
306     // We can overhang the ruby by no more than half the width of the neighboring text
307     // and no more than half the font size.
308     int halfWidthOfFontSize = rubyText->style(firstLine)->fontSize() / 2;
309     if (startOverhang)
310         startOverhang = min<int>(startOverhang, min<int>(toRenderText(startRenderer)->minLogicalWidth(), halfWidthOfFontSize));
311     if (endOverhang)
312         endOverhang = min<int>(endOverhang, min<int>(toRenderText(endRenderer)->minLogicalWidth(), halfWidthOfFontSize));
313 }
314
315 } // namespace WebCore