Home | History | Annotate | Download | only in dom 
      1 /*
      2  * Copyright (C) 2011 Adobe Systems Incorporated. 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
      6  * are met:
      7  *
      8  * 1. Redistributions of source code must retain the above
      9  *    copyright notice, this list of conditions and the following
     10  *    disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above
     12  *    copyright notice, this list of conditions and the following
     13  *    disclaimer in the documentation and/or other materials
     14  *    provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
     17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
     20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
     21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
     25  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
     26  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     27  * SUCH DAMAGE.
     28  */
     29 
     30 #include "config.h"
     31 #include "core/dom/NamedFlow.h"
     32 
     33 #include "RuntimeEnabledFeatures.h"
     34 #include "core/dom/NamedFlowCollection.h"
     35 #include "core/dom/StaticNodeList.h"
     36 #include "core/events/ThreadLocalEventNames.h"
     37 #include "core/events/UIEvent.h"
     38 #include "core/rendering/RenderNamedFlowFragment.h"
     39 #include "core/rendering/RenderNamedFlowThread.h"
     40 
     41 namespace WebCore {
     42 
     43 NamedFlow::NamedFlow(PassRefPtr<NamedFlowCollection> manager, const AtomicString& flowThreadName)
     44     : m_flowThreadName(flowThreadName)
     45     , m_flowManager(manager)
     46     , m_parentFlowThread(0)
     47 {
     48     ASSERT(RuntimeEnabledFeatures::cssRegionsEnabled());
     49     ScriptWrappable::init(this);
     50 }
     51 
     52 NamedFlow::~NamedFlow()
     53 {
     54     // The named flow is not "strong" referenced from anywhere at this time so it shouldn't be reused if the named flow is recreated.
     55     m_flowManager->discardNamedFlow(this);
     56 }
     57 
     58 PassRefPtr<NamedFlow> NamedFlow::create(PassRefPtr<NamedFlowCollection> manager, const AtomicString& flowThreadName)
     59 {
     60     return adoptRef(new NamedFlow(manager, flowThreadName));
     61 }
     62 
     63 const AtomicString& NamedFlow::name() const
     64 {
     65     return m_flowThreadName;
     66 }
     67 
     68 bool NamedFlow::overset() const
     69 {
     70     if (m_flowManager->document())
     71         m_flowManager->document()->updateLayoutIgnorePendingStylesheets();
     72 
     73     // The renderer may be destroyed or created after the style update.
     74     // Because this is called from JS, where the wrapper keeps a reference to the NamedFlow, no guard is necessary.
     75     return m_parentFlowThread ? m_parentFlowThread->overset() : true;
     76 }
     77 
     78 static inline bool inFlowThread(RenderObject* renderer, RenderNamedFlowThread* flowThread)
     79 {
     80     if (!renderer)
     81         return false;
     82     RenderFlowThread* currentFlowThread = renderer->flowThreadContainingBlock();
     83     if (flowThread == currentFlowThread)
     84         return true;
     85     if (renderer->flowThreadState() != RenderObject::InsideInFlowThread)
     86         return false;
     87 
     88     // An in-flow flow thread can be nested inside an out-of-flow one, so we have to recur up to check.
     89     return inFlowThread(currentFlowThread->containingBlock(), flowThread);
     90 }
     91 
     92 int NamedFlow::firstEmptyRegionIndex() const
     93 {
     94     if (m_flowManager->document())
     95         m_flowManager->document()->updateLayoutIgnorePendingStylesheets();
     96 
     97     if (!m_parentFlowThread)
     98         return -1;
     99 
    100     const RenderRegionList& regionList = m_parentFlowThread->renderRegionList();
    101     if (regionList.isEmpty())
    102         return -1;
    103 
    104     int countNonPseudoRegions = -1;
    105     RenderRegionList::const_iterator iter = regionList.begin();
    106     for (int index = 0; iter != regionList.end(); ++index, ++iter) {
    107         const RenderNamedFlowFragment* renderRegion = toRenderNamedFlowFragment(*iter);
    108         // FIXME: Pseudo-elements are not included in the list.
    109         // They will be included when we will properly support the Region interface
    110         // http://dev.w3.org/csswg/css-regions/#the-region-interface
    111         if (!renderRegion->isElementBasedRegion())
    112             continue;
    113         countNonPseudoRegions++;
    114         if (renderRegion->regionOversetState() == RegionEmpty)
    115             return countNonPseudoRegions;
    116     }
    117     return -1;
    118 }
    119 
    120 PassRefPtr<NodeList> NamedFlow::getRegionsByContent(Node* contentNode)
    121 {
    122     Vector<RefPtr<Node> > regionNodes;
    123 
    124     if (!contentNode)
    125         return StaticNodeList::adopt(regionNodes);
    126 
    127     if (m_flowManager->document())
    128         m_flowManager->document()->updateLayoutIgnorePendingStylesheets();
    129 
    130     // The renderer may be destroyed or created after the style update.
    131     // Because this is called from JS, where the wrapper keeps a reference to the NamedFlow, no guard is necessary.
    132     if (!m_parentFlowThread)
    133         return StaticNodeList::adopt(regionNodes);
    134 
    135     if (inFlowThread(contentNode->renderer(), m_parentFlowThread)) {
    136         const RenderRegionList& regionList = m_parentFlowThread->renderRegionList();
    137         for (RenderRegionList::const_iterator iter = regionList.begin(); iter != regionList.end(); ++iter) {
    138             const RenderNamedFlowFragment* renderRegion = toRenderNamedFlowFragment(*iter);
    139             // They will be included when we will properly support the Region interface
    140             // http://dev.w3.org/csswg/css-regions/#the-region-interface
    141             if (!renderRegion->isElementBasedRegion())
    142                 continue;
    143             if (m_parentFlowThread->objectInFlowRegion(contentNode->renderer(), renderRegion))
    144                 regionNodes.append(renderRegion->nodeForRegion());
    145         }
    146     }
    147 
    148     return StaticNodeList::adopt(regionNodes);
    149 }
    150 
    151 PassRefPtr<NodeList> NamedFlow::getRegions()
    152 {
    153     Vector<RefPtr<Node> > regionNodes;
    154 
    155     if (m_flowManager->document())
    156         m_flowManager->document()->updateLayoutIgnorePendingStylesheets();
    157 
    158     // The renderer may be destroyed or created after the style update.
    159     // Because this is called from JS, where the wrapper keeps a reference to the NamedFlow, no guard is necessary.
    160     if (!m_parentFlowThread)
    161         return StaticNodeList::adopt(regionNodes);
    162 
    163     const RenderRegionList& regionList = m_parentFlowThread->renderRegionList();
    164     for (RenderRegionList::const_iterator iter = regionList.begin(); iter != regionList.end(); ++iter) {
    165         const RenderNamedFlowFragment* renderRegion = toRenderNamedFlowFragment(*iter);
    166         // They will be included when we will properly support the Region interface
    167         // http://dev.w3.org/csswg/css-regions/#the-region-interface
    168         if (!renderRegion->isElementBasedRegion())
    169             continue;
    170         regionNodes.append(renderRegion->nodeForRegion());
    171     }
    172 
    173     return StaticNodeList::adopt(regionNodes);
    174 }
    175 
    176 PassRefPtr<NodeList> NamedFlow::getContent()
    177 {
    178     Vector<RefPtr<Node> > contentNodes;
    179 
    180     if (m_flowManager->document())
    181         m_flowManager->document()->updateLayoutIgnorePendingStylesheets();
    182 
    183     // The renderer may be destroyed or created after the style update.
    184     // Because this is called from JS, where the wrapper keeps a reference to the NamedFlow, no guard is necessary.
    185     if (!m_parentFlowThread)
    186         return StaticNodeList::adopt(contentNodes);
    187 
    188     const NamedFlowContentNodes& contentNodesList = m_parentFlowThread->contentNodes();
    189     for (NamedFlowContentNodes::const_iterator it = contentNodesList.begin(); it != contentNodesList.end(); ++it) {
    190         Node* node = *it;
    191         ASSERT(node->computedStyle()->flowThread() == m_parentFlowThread->flowThreadName());
    192         contentNodes.append(node);
    193     }
    194 
    195     return StaticNodeList::adopt(contentNodes);
    196 }
    197 
    198 void NamedFlow::setRenderer(RenderNamedFlowThread* parentFlowThread)
    199 {
    200     // The named flow can either go from a no_renderer->renderer or renderer->no_renderer state; anything else could indicate a bug.
    201     ASSERT((!m_parentFlowThread && parentFlowThread) || (m_parentFlowThread && !parentFlowThread));
    202 
    203     // If parentFlowThread is 0, the flow thread will move in the "NULL" state.
    204     m_parentFlowThread = parentFlowThread;
    205 }
    206 
    207 void NamedFlow::dispatchRegionLayoutUpdateEvent()
    208 {
    209     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
    210 
    211     // If the flow is in the "NULL" state the event should not be dispatched any more.
    212     if (flowState() == FlowStateNull)
    213         return;
    214 
    215     RefPtr<Event> event = UIEvent::create(EventTypeNames::webkitregionlayoutupdate, false, false, m_flowManager->document()->domWindow(), 0);
    216 
    217     dispatchEvent(event);
    218 }
    219 
    220 void NamedFlow::dispatchRegionOversetChangeEvent()
    221 {
    222     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
    223 
    224     // If the flow is in the "NULL" state the event should not be dispatched any more.
    225     if (flowState() == FlowStateNull)
    226         return;
    227 
    228     RefPtr<Event> event = UIEvent::create(EventTypeNames::webkitregionoversetchange, false, false, m_flowManager->document()->domWindow(), 0);
    229 
    230     dispatchEvent(event);
    231 }
    232 
    233 const AtomicString& NamedFlow::interfaceName() const
    234 {
    235     return EventTargetNames::NamedFlow;
    236 }
    237 
    238 ExecutionContext* NamedFlow::executionContext() const
    239 {
    240     return m_flowManager->document();
    241 }
    242 
    243 Node* NamedFlow::ownerNode() const
    244 {
    245     return m_flowManager->document();
    246 }
    247 
    248 } // namespace WebCore
    249 
    250