| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
reserved. | |
| 3 * | |
| 4 * Portions are Copyright (C) 1998 Netscape Communications Corporation. | |
| 5 * | |
| 6 * Other contributors: | |
| 7 * Robert O'Callahan <roc+@cs.cmu.edu> | |
| 8 * David Baron <dbaron@fas.harvard.edu> | |
| 9 * Christian Biesinger <cbiesinger@web.de> | |
| 10 * Randall Jesup <rjesup@wgate.com> | |
| 11 * Roland Mainz <roland.mainz@informatik.med.uni-giessen.de> | |
| 12 * Josh Soref <timeless@mac.com> | |
| 13 * Boris Zbarsky <bzbarsky@mit.edu> | |
| 14 * | |
| 15 * This library is free software; you can redistribute it and/or | |
| 16 * modify it under the terms of the GNU Lesser General Public | |
| 17 * License as published by the Free Software Foundation; either | |
| 18 * version 2.1 of the License, or (at your option) any later version. | |
| 19 * | |
| 20 * This library is distributed in the hope that it will be useful, | |
| 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 23 * Lesser General Public License for more details. | |
| 24 * | |
| 25 * You should have received a copy of the GNU Lesser General Public | |
| 26 * License along with this library; if not, write to the Free Software | |
| 27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 US
A | |
| 28 * | |
| 29 * Alternatively, the contents of this file may be used under the terms | |
| 30 * of either the Mozilla Public License Version 1.1, found at | |
| 31 * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public | |
| 32 * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html | |
| 33 * (the "GPL"), in which case the provisions of the MPL or the GPL are | |
| 34 * applicable instead of those above. If you wish to allow use of your | |
| 35 * version of this file only under the terms of one of those two | |
| 36 * licenses (the MPL or the GPL) and not to allow others to use your | |
| 37 * version of this file under the LGPL, indicate your decision by | |
| 38 * deletingthe provisions above and replace them with the notice and | |
| 39 * other provisions required by the MPL or the GPL, as the case may be. | |
| 40 * If you do not delete the provisions above, a recipient may use your | |
| 41 * version of this file under any of the LGPL, the MPL or the GPL. | |
| 42 */ | |
| 43 | |
| 44 #include "config.h" | |
| 45 #include "core/rendering/RenderLayerStackingNode.h" | |
| 46 | |
| 47 #include "core/layout/compositing/RenderLayerCompositor.h" | |
| 48 #include "core/rendering/RenderLayer.h" | |
| 49 #include "core/rendering/RenderView.h" | |
| 50 #include "public/platform/Platform.h" | |
| 51 | |
| 52 namespace blink { | |
| 53 | |
| 54 // FIXME: This should not require RenderLayer. There is currently a cycle where | |
| 55 // in order to determine if we shoulBeNormalFlowOnly() we have to ask the render | |
| 56 // layer about some of its state. | |
| 57 RenderLayerStackingNode::RenderLayerStackingNode(RenderLayer* layer) | |
| 58 : m_layer(layer) | |
| 59 , m_normalFlowListDirty(true) | |
| 60 #if ENABLE(ASSERT) | |
| 61 , m_layerListMutationAllowed(true) | |
| 62 , m_stackingParent(0) | |
| 63 #endif | |
| 64 { | |
| 65 m_isNormalFlowOnly = shouldBeNormalFlowOnly(); | |
| 66 | |
| 67 // Non-stacking contexts should have empty z-order lists. As this is already
the case, | |
| 68 // there is no need to dirty / recompute these lists. | |
| 69 m_zOrderListsDirty = isStackingContext(); | |
| 70 } | |
| 71 | |
| 72 RenderLayerStackingNode::~RenderLayerStackingNode() | |
| 73 { | |
| 74 #if ENABLE(ASSERT) | |
| 75 if (!renderer()->documentBeingDestroyed()) { | |
| 76 ASSERT(!isInStackingParentZOrderLists()); | |
| 77 ASSERT(!isInStackingParentNormalFlowList()); | |
| 78 | |
| 79 updateStackingParentForZOrderLists(0); | |
| 80 updateStackingParentForNormalFlowList(0); | |
| 81 } | |
| 82 #endif | |
| 83 } | |
| 84 | |
| 85 // Helper for the sorting of layers by z-index. | |
| 86 static inline bool compareZIndex(RenderLayerStackingNode* first, RenderLayerStac
kingNode* second) | |
| 87 { | |
| 88 return first->zIndex() < second->zIndex(); | |
| 89 } | |
| 90 | |
| 91 RenderLayerCompositor* RenderLayerStackingNode::compositor() const | |
| 92 { | |
| 93 ASSERT(renderer()->view()); | |
| 94 return renderer()->view()->compositor(); | |
| 95 } | |
| 96 | |
| 97 void RenderLayerStackingNode::dirtyZOrderLists() | |
| 98 { | |
| 99 ASSERT(m_layerListMutationAllowed); | |
| 100 ASSERT(isStackingContext()); | |
| 101 | |
| 102 #if ENABLE(ASSERT) | |
| 103 updateStackingParentForZOrderLists(0); | |
| 104 #endif | |
| 105 | |
| 106 if (m_posZOrderList) | |
| 107 m_posZOrderList->clear(); | |
| 108 if (m_negZOrderList) | |
| 109 m_negZOrderList->clear(); | |
| 110 m_zOrderListsDirty = true; | |
| 111 | |
| 112 if (!renderer()->documentBeingDestroyed()) | |
| 113 compositor()->setNeedsCompositingUpdate(CompositingUpdateRebuildTree); | |
| 114 } | |
| 115 | |
| 116 void RenderLayerStackingNode::dirtyStackingContextZOrderLists() | |
| 117 { | |
| 118 if (RenderLayerStackingNode* stackingNode = ancestorStackingContextNode()) | |
| 119 stackingNode->dirtyZOrderLists(); | |
| 120 } | |
| 121 | |
| 122 void RenderLayerStackingNode::dirtyNormalFlowList() | |
| 123 { | |
| 124 ASSERT(m_layerListMutationAllowed); | |
| 125 | |
| 126 #if ENABLE(ASSERT) | |
| 127 updateStackingParentForNormalFlowList(0); | |
| 128 #endif | |
| 129 | |
| 130 if (m_normalFlowList) | |
| 131 m_normalFlowList->clear(); | |
| 132 m_normalFlowListDirty = true; | |
| 133 | |
| 134 if (!renderer()->documentBeingDestroyed()) | |
| 135 compositor()->setNeedsCompositingUpdate(CompositingUpdateRebuildTree); | |
| 136 } | |
| 137 | |
| 138 void RenderLayerStackingNode::rebuildZOrderLists() | |
| 139 { | |
| 140 ASSERT(m_layerListMutationAllowed); | |
| 141 ASSERT(isDirtyStackingContext()); | |
| 142 | |
| 143 for (RenderLayer* child = layer()->firstChild(); child; child = child->nextS
ibling()) { | |
| 144 if (!layer()->reflectionInfo() || layer()->reflectionInfo()->reflectionL
ayer() != child) | |
| 145 child->stackingNode()->collectLayers(m_posZOrderList, m_negZOrderLis
t); | |
| 146 } | |
| 147 | |
| 148 // Sort the two lists. | |
| 149 if (m_posZOrderList) | |
| 150 std::stable_sort(m_posZOrderList->begin(), m_posZOrderList->end(), compa
reZIndex); | |
| 151 | |
| 152 if (m_negZOrderList) | |
| 153 std::stable_sort(m_negZOrderList->begin(), m_negZOrderList->end(), compa
reZIndex); | |
| 154 | |
| 155 // Append layers for top layer elements after normal layer collection, to en
sure they are on top regardless of z-indexes. | |
| 156 // The renderers of top layer elements are children of the view, sorted in t
op layer stacking order. | |
| 157 if (layer()->isRootLayer()) { | |
| 158 RenderView* view = renderer()->view(); | |
| 159 for (RenderObject* child = view->firstChild(); child; child = child->nex
tSibling()) { | |
| 160 Element* childElement = (child->node() && child->node()->isElementNo
de()) ? toElement(child->node()) : 0; | |
| 161 if (childElement && childElement->isInTopLayer()) { | |
| 162 RenderLayer* layer = toRenderLayerModelObject(child)->layer(); | |
| 163 // Create the buffer if it doesn't exist yet. | |
| 164 if (!m_posZOrderList) | |
| 165 m_posZOrderList = adoptPtr(new Vector<RenderLayerStackingNod
e*>); | |
| 166 m_posZOrderList->append(layer->stackingNode()); | |
| 167 } | |
| 168 } | |
| 169 } | |
| 170 | |
| 171 #if ENABLE(ASSERT) | |
| 172 updateStackingParentForZOrderLists(this); | |
| 173 #endif | |
| 174 | |
| 175 m_zOrderListsDirty = false; | |
| 176 } | |
| 177 | |
| 178 void RenderLayerStackingNode::updateNormalFlowList() | |
| 179 { | |
| 180 if (!m_normalFlowListDirty) | |
| 181 return; | |
| 182 | |
| 183 ASSERT(m_layerListMutationAllowed); | |
| 184 | |
| 185 for (RenderLayer* child = layer()->firstChild(); child; child = child->nextS
ibling()) { | |
| 186 if (child->stackingNode()->isNormalFlowOnly() && (!layer()->reflectionIn
fo() || layer()->reflectionInfo()->reflectionLayer() != child)) { | |
| 187 if (!m_normalFlowList) | |
| 188 m_normalFlowList = adoptPtr(new Vector<RenderLayerStackingNode*>
); | |
| 189 m_normalFlowList->append(child->stackingNode()); | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 #if ENABLE(ASSERT) | |
| 194 updateStackingParentForNormalFlowList(this); | |
| 195 #endif | |
| 196 | |
| 197 m_normalFlowListDirty = false; | |
| 198 } | |
| 199 | |
| 200 void RenderLayerStackingNode::collectLayers(OwnPtr<Vector<RenderLayerStackingNod
e*> >& posBuffer, OwnPtr<Vector<RenderLayerStackingNode*> >& negBuffer) | |
| 201 { | |
| 202 if (layer()->isInTopLayer()) | |
| 203 return; | |
| 204 | |
| 205 if (!isNormalFlowOnly()) { | |
| 206 OwnPtr<Vector<RenderLayerStackingNode*> >& buffer = (zIndex() >= 0) ? po
sBuffer : negBuffer; | |
| 207 if (!buffer) | |
| 208 buffer = adoptPtr(new Vector<RenderLayerStackingNode*>); | |
| 209 buffer->append(this); | |
| 210 } | |
| 211 | |
| 212 if (!isStackingContext()) { | |
| 213 for (RenderLayer* child = layer()->firstChild(); child; child = child->n
extSibling()) { | |
| 214 if (!layer()->reflectionInfo() || layer()->reflectionInfo()->reflect
ionLayer() != child) | |
| 215 child->stackingNode()->collectLayers(posBuffer, negBuffer); | |
| 216 } | |
| 217 } | |
| 218 } | |
| 219 | |
| 220 #if ENABLE(ASSERT) | |
| 221 bool RenderLayerStackingNode::isInStackingParentZOrderLists() const | |
| 222 { | |
| 223 if (!m_stackingParent || m_stackingParent->zOrderListsDirty()) | |
| 224 return false; | |
| 225 | |
| 226 if (m_stackingParent->posZOrderList() && m_stackingParent->posZOrderList()->
find(this) != kNotFound) | |
| 227 return true; | |
| 228 | |
| 229 if (m_stackingParent->negZOrderList() && m_stackingParent->negZOrderList()->
find(this) != kNotFound) | |
| 230 return true; | |
| 231 | |
| 232 return false; | |
| 233 } | |
| 234 | |
| 235 bool RenderLayerStackingNode::isInStackingParentNormalFlowList() const | |
| 236 { | |
| 237 if (!m_stackingParent || m_stackingParent->normalFlowListDirty()) | |
| 238 return false; | |
| 239 | |
| 240 return (m_stackingParent->normalFlowList() && m_stackingParent->normalFlowLi
st()->find(this) != kNotFound); | |
| 241 } | |
| 242 | |
| 243 void RenderLayerStackingNode::updateStackingParentForZOrderLists(RenderLayerStac
kingNode* stackingParent) | |
| 244 { | |
| 245 if (m_posZOrderList) { | |
| 246 for (size_t i = 0; i < m_posZOrderList->size(); ++i) | |
| 247 m_posZOrderList->at(i)->setStackingParent(stackingParent); | |
| 248 } | |
| 249 | |
| 250 if (m_negZOrderList) { | |
| 251 for (size_t i = 0; i < m_negZOrderList->size(); ++i) | |
| 252 m_negZOrderList->at(i)->setStackingParent(stackingParent); | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 void RenderLayerStackingNode::updateStackingParentForNormalFlowList(RenderLayerS
tackingNode* stackingParent) | |
| 257 { | |
| 258 if (m_normalFlowList) { | |
| 259 for (size_t i = 0; i < m_normalFlowList->size(); ++i) | |
| 260 m_normalFlowList->at(i)->setStackingParent(stackingParent); | |
| 261 } | |
| 262 } | |
| 263 #endif | |
| 264 | |
| 265 void RenderLayerStackingNode::updateLayerListsIfNeeded() | |
| 266 { | |
| 267 updateZOrderLists(); | |
| 268 updateNormalFlowList(); | |
| 269 | |
| 270 if (!layer()->reflectionInfo()) | |
| 271 return; | |
| 272 | |
| 273 RenderLayer* reflectionLayer = layer()->reflectionInfo()->reflectionLayer(); | |
| 274 reflectionLayer->stackingNode()->updateZOrderLists(); | |
| 275 reflectionLayer->stackingNode()->updateNormalFlowList(); | |
| 276 } | |
| 277 | |
| 278 void RenderLayerStackingNode::updateStackingNodesAfterStyleChange(const RenderSt
yle* oldStyle) | |
| 279 { | |
| 280 bool wasStackingContext = oldStyle ? !oldStyle->hasAutoZIndex() : false; | |
| 281 int oldZIndex = oldStyle ? oldStyle->zIndex() : 0; | |
| 282 | |
| 283 bool isStackingContext = this->isStackingContext(); | |
| 284 if (isStackingContext == wasStackingContext && oldZIndex == zIndex()) | |
| 285 return; | |
| 286 | |
| 287 dirtyStackingContextZOrderLists(); | |
| 288 | |
| 289 if (isStackingContext) | |
| 290 dirtyZOrderLists(); | |
| 291 else | |
| 292 clearZOrderLists(); | |
| 293 } | |
| 294 | |
| 295 // FIXME: Rename shouldBeNormalFlowOnly to something more accurate now that CSS | |
| 296 // 2.1 defines the term "normal flow". | |
| 297 bool RenderLayerStackingNode::shouldBeNormalFlowOnly() const | |
| 298 { | |
| 299 return !isStackingContext() && !renderer()->isPositioned(); | |
| 300 } | |
| 301 | |
| 302 void RenderLayerStackingNode::updateIsNormalFlowOnly() | |
| 303 { | |
| 304 bool isNormalFlowOnly = shouldBeNormalFlowOnly(); | |
| 305 if (isNormalFlowOnly == this->isNormalFlowOnly()) | |
| 306 return; | |
| 307 | |
| 308 m_isNormalFlowOnly = isNormalFlowOnly; | |
| 309 if (RenderLayer* p = layer()->parent()) | |
| 310 p->stackingNode()->dirtyNormalFlowList(); | |
| 311 dirtyStackingContextZOrderLists(); | |
| 312 } | |
| 313 | |
| 314 RenderLayerStackingNode* RenderLayerStackingNode::ancestorStackingContextNode()
const | |
| 315 { | |
| 316 for (RenderLayer* ancestor = layer()->parent(); ancestor; ancestor = ancesto
r->parent()) { | |
| 317 RenderLayerStackingNode* stackingNode = ancestor->stackingNode(); | |
| 318 if (stackingNode->isStackingContext()) | |
| 319 return stackingNode; | |
| 320 } | |
| 321 return 0; | |
| 322 } | |
| 323 | |
| 324 RenderLayerModelObject* RenderLayerStackingNode::renderer() const | |
| 325 { | |
| 326 return m_layer->renderer(); | |
| 327 } | |
| 328 | |
| 329 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 898783003:
Move rendering/RenderLayer* to layout/ (Closed)
Base URL: svn://svn.chromium.org/blink/trunk