src/third_party/WebKit/Source/core/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 "core/rendering/RenderRuby.h"
  34
  35 #include "core/rendering/RenderRubyRun.h"
  36 #include "core/rendering/style/RenderStyle.h"
  37 #include "wtf/RefPtr.h"
  38
  39 namespace WebCore {
  40
  41 //=== generic helper functions to avoid excessive code duplication ===
  42
  43 static inline bool isAnonymousRubyInlineBlock(const RenderObject* object)
  44 {
  45     ASSERT(!object
  46         || !object->parent()->isRuby()
  47         || object->isRubyRun()
  48         || (object->isInline() && (object->isBeforeContent() || object->isAfterContent()))
  49         || (object->isAnonymous() && object->isRenderBlock() && object->style()->display() == INLINE_BLOCK));
  50
  51     return object
  52         && object->parent()->isRuby()
  53         && object->isRenderBlock()
  54         && !object->isRubyRun();
  55 }
  56
  57 static inline bool isRubyBeforeBlock(const RenderObject* object)
  58 {
  59     return isAnonymousRubyInlineBlock(object)
  60         && !object->previousSibling()
  61         && object->firstChild()
  62         && object->firstChild()->style()->styleType() == BEFORE;
  63 }
  64
  65 static inline bool isRubyAfterBlock(const RenderObject* object)
  66 {
  67     return isAnonymousRubyInlineBlock(object)
  68         && !object->nextSibling()
  69         && object->firstChild()
  70         && object->firstChild()->style()->styleType() == AFTER;
  71 }
  72
  73 static inline RenderBlock* rubyBeforeBlock(const RenderObject* ruby)
  74 {
  75     RenderObject* child = ruby->firstChild();
  76     return isRubyBeforeBlock(child) ? toRenderBlock(child) : 0;
  77 }
  78
  79 static inline RenderBlock* rubyAfterBlock(const RenderObject* ruby)
  80 {
  81     RenderObject* child = ruby->lastChild();
  82     return isRubyAfterBlock(child) ? toRenderBlock(child) : 0;
  83 }
  84
  85 static RenderBlockFlow* createAnonymousRubyInlineBlock(RenderObject* ruby)
  86 {
  87     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(ruby->style(), INLINE_BLOCK);
  88     RenderBlockFlow* newBlock = RenderBlockFlow::createAnonymous(&ruby->document());
  89     newBlock->setStyle(newStyle.release());
  90     return newBlock;
  91 }
  92
  93 static RenderRubyRun* lastRubyRun(const RenderObject* ruby)
  94 {
  95     RenderObject* child = ruby->lastChild();
  96     if (child && !child->isRubyRun())
  97         child = child->previousSibling();
  98     ASSERT(!child || child->isRubyRun() || child->isBeforeContent() || child == rubyBeforeBlock(ruby));
  99     return child && child->isRubyRun() ? toRenderRubyRun(child) : 0;
 100 }
 101
 102 static inline RenderRubyRun* findRubyRunParent(RenderObject* child)
 103 {
 104     while (child && !child->isRubyRun())
 105         child = child->parent();
 106     return toRenderRubyRun(child);
 107 }
 108
 109 //=== ruby as inline object ===
 110
 111 RenderRubyAsInline::RenderRubyAsInline(Element* element)
 112     : RenderInline(element)
 113 {
 114 }
 115
 116 RenderRubyAsInline::~RenderRubyAsInline()
 117 {
 118 }
 119
 120 void RenderRubyAsInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 121 {
 122     RenderInline::styleDidChange(diff, oldStyle);
 123     propagateStyleToAnonymousChildren();
 124 }
 125
 126 void RenderRubyAsInline::addChild(RenderObject* child, RenderObject* beforeChild)
 127 {
 128     // Insert :before and :after content before/after the RenderRubyRun(s)
 129     if (child->isBeforeContent()) {
 130         if (child->isInline()) {
 131             // Add generated inline content normally
 132             RenderInline::addChild(child, firstChild());
 133         } else {
 134             // Wrap non-inline content with an anonymous inline-block.
 135             RenderBlock* beforeBlock = rubyBeforeBlock(this);
 136             if (!beforeBlock) {
 137                 beforeBlock = createAnonymousRubyInlineBlock(this);
 138                 RenderInline::addChild(beforeBlock, firstChild());
 139             }
 140             beforeBlock->addChild(child);
 141         }
 142         return;
 143     }
 144     if (child->isAfterContent()) {
 145         if (child->isInline()) {
 146             // Add generated inline content normally
 147             RenderInline::addChild(child);
 148         } else {
 149             // Wrap non-inline content with an anonymous inline-block.
 150             RenderBlock* afterBlock = rubyAfterBlock(this);
 151             if (!afterBlock) {
 152                 afterBlock = createAnonymousRubyInlineBlock(this);
 153                 RenderInline::addChild(afterBlock);
 154             }
 155             afterBlock->addChild(child);
 156         }
 157         return;
 158     }
 159
 160     // If the child is a ruby run, just add it normally.
 161     if (child->isRubyRun()) {
 162         RenderInline::addChild(child, beforeChild);
 163         return;
 164     }
 165
 166     if (beforeChild && !isAfterContent(beforeChild)) {
 167         // insert child into run
 168         ASSERT(!beforeChild->isRubyRun());
 169         RenderObject* run = beforeChild;
 170         while (run && !run->isRubyRun())
 171             run = run->parent();
 172         if (run) {
 173             run->addChild(child, beforeChild);
 174             return;
 175         }
 176         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
 177         // Emergency fallback: fall through and just append.
 178     }
 179
 180     // If the new child would be appended, try to add the child to the previous run
 181     // if possible, or create a new run otherwise.
 182     // (The RenderRubyRun object will handle the details)
 183     RenderRubyRun* lastRun = lastRubyRun(this);
 184     if (!lastRun || lastRun->hasRubyText()) {
 185         lastRun = RenderRubyRun::staticCreateRubyRun(this);
 186         RenderInline::addChild(lastRun, beforeChild);
 187     }
 188     lastRun->addChild(child);
 189 }
 190
 191 void RenderRubyAsInline::removeChild(RenderObject* child)
 192 {
 193     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
 194     // just use the normal remove method.
 195     if (child->parent() == this) {
 196         ASSERT(child->isRubyRun() || child->isBeforeContent() || child->isAfterContent() || isAnonymousRubyInlineBlock(child));
 197         RenderInline::removeChild(child);
 198         return;
 199     }
 200     // If the child's parent is an anoymous block (must be generated :before/:after content)
 201     // just use the block's remove method.
 202     if (isAnonymousRubyInlineBlock(child->parent())) {
 203         ASSERT(child->isBeforeContent() || child->isAfterContent());
 204         child->parent()->removeChild(child);
 205         removeChild(child->parent());
 206         return;
 207     }
 208
 209     // Otherwise find the containing run and remove it from there.
 210     RenderRubyRun* run = findRubyRunParent(child);
 211     ASSERT(run);
 212     run->removeChild(child);
 213 }
 214
 215 //=== ruby as block object ===
 216
 217 RenderRubyAsBlock::RenderRubyAsBlock(Element* element)
 218     : RenderBlockFlow(element)
 219 {
 220 }
 221
 222 RenderRubyAsBlock::~RenderRubyAsBlock()
 223 {
 224 }
 225
 226 void RenderRubyAsBlock::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 227 {
 228     RenderBlock::styleDidChange(diff, oldStyle);
 229     propagateStyleToAnonymousChildren();
 230 }
 231
 232 void RenderRubyAsBlock::addChild(RenderObject* child, RenderObject* beforeChild)
 233 {
 234     // Insert :before and :after content before/after the RenderRubyRun(s)
 235     if (child->isBeforeContent()) {
 236         if (child->isInline()) {
 237             // Add generated inline content normally
 238             RenderBlock::addChild(child, firstChild());
 239         } else {
 240             // Wrap non-inline content with an anonymous inline-block.
 241             RenderBlock* beforeBlock = rubyBeforeBlock(this);
 242             if (!beforeBlock) {
 243                 beforeBlock = createAnonymousRubyInlineBlock(this);
 244                 RenderBlock::addChild(beforeBlock, firstChild());
 245             }
 246             beforeBlock->addChild(child);
 247         }
 248         return;
 249     }
 250     if (child->isAfterContent()) {
 251         if (child->isInline()) {
 252             // Add generated inline content normally
 253             RenderBlock::addChild(child);
 254         } else {
 255             // Wrap non-inline content with an anonymous inline-block.
 256             RenderBlock* afterBlock = rubyAfterBlock(this);
 257             if (!afterBlock) {
 258                 afterBlock = createAnonymousRubyInlineBlock(this);
 259                 RenderBlock::addChild(afterBlock);
 260             }
 261             afterBlock->addChild(child);
 262         }
 263         return;
 264     }
 265
 266     // If the child is a ruby run, just add it normally.
 267     if (child->isRubyRun()) {
 268         RenderBlock::addChild(child, beforeChild);
 269         return;
 270     }
 271
 272     if (beforeChild && !isAfterContent(beforeChild)) {
 273         // insert child into run
 274         ASSERT(!beforeChild->isRubyRun());
 275         RenderObject* run = beforeChild;
 276         while (run && !run->isRubyRun())
 277             run = run->parent();
 278         if (run) {
 279             run->addChild(child, beforeChild);
 280             return;
 281         }
 282         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
 283         // Emergency fallback: fall through and just append.
 284     }
 285
 286     // If the new child would be appended, try to add the child to the previous run
 287     // if possible, or create a new run otherwise.
 288     // (The RenderRubyRun object will handle the details)
 289     RenderRubyRun* lastRun = lastRubyRun(this);
 290     if (!lastRun || lastRun->hasRubyText()) {
 291         lastRun = RenderRubyRun::staticCreateRubyRun(this);
 292         RenderBlock::addChild(lastRun, beforeChild);
 293     }
 294     lastRun->addChild(child);
 295 }
 296
 297 void RenderRubyAsBlock::removeChild(RenderObject* child)
 298 {
 299     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
 300     // just use the normal remove method.
 301     if (child->parent() == this) {
 302         ASSERT(child->isRubyRun() || child->isBeforeContent() || child->isAfterContent() || isAnonymousRubyInlineBlock(child));
 303         RenderBlock::removeChild(child);
 304         return;
 305     }
 306     // If the child's parent is an anoymous block (must be generated :before/:after content)
 307     // just use the block's remove method.
 308     if (isAnonymousRubyInlineBlock(child->parent())) {
 309         ASSERT(child->isBeforeContent() || child->isAfterContent());
 310         child->parent()->removeChild(child);
 311         removeChild(child->parent());
 312         return;
 313     }
 314
 315     // Otherwise find the containing run and remove it from there.
 316     RenderRubyRun* run = findRubyRunParent(child);
 317     ASSERT(run);
 318     run->removeChild(child);
 319 }
 320
 321 } // namespace WebCore