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