render_layer.cpp

@@void RenderLayer::clearClipRect()

    }

}

static RenderObject* commonAncestor(RenderObject* obj1, RenderObject* obj2)

{

    if (!obj1 || !obj2)

        return 0;

    for (RenderObject* currObj1 = obj1; currObj1; currObj1 = currObj1->hoverAncestor())

        for (RenderObject* currObj2 = obj2; currObj2; currObj2 = currObj2->hoverAncestor())

            if (currObj1 == currObj2)

                return currObj1;

    return 0;

}

void RenderLayer::updateHoverActiveState(RenderObject::NodeInfo& info)

{

    // We don't update :hover/:active state when the info is marked as readonly.

@@void RenderLayer::updateHoverActiveState

        return;

    DocumentImpl* doc = renderer()->document();

1358 if (!doc) return;

1345 if (!doc)

1346 return;

13591347

1348 NodeImpl* newHoverNode = info.innerNode();

13601349 NodeImpl* activeNode = doc->activeNode();

    if (activeNode && !info.active()) {

        // We are clearing the :active chain because the mouse has been released.

        for (RenderObject* curr = activeNode->renderer(); curr; curr = curr->parent()) {

            if (curr->element() && !curr->isText())

                curr->element()->setInActiveChain(false);

        }

        doc->setActiveNode(0);

    } else {

        NodeImpl* newActiveNode = info.innerNode();

        if (!activeNode && newActiveNode && info.active()) {

            // We are setting the :active chain and freezing it. If future moves happen, they

            // will need to reference this chain.

            for (RenderObject* curr = newActiveNode->renderer(); curr; curr = curr->parent()) {

                if (curr->element() && !curr->isText()) {

                    curr->element()->setInActiveChain(true);

                }

            }

            doc->setActiveNode(newActiveNode);

        }

    }

    // If the mouse is down and if this is a mouse move event, we want to restrict changes in 

    // :hover/:active to only apply to elements that are in the :active chain that we froze

    // at the time the mouse went down.

    bool mustBeInActiveChain = info.active() && info.mouseMove();

13861350

    // Check to see if the hovered node has changed.  If not, then we don't need to

    // do anything.  

    DOM::NodeImpl* oldHoverNode = doc->hoverNode();

    DOM::NodeImpl* newHoverNode = info.innerNode();

    if (activeNode && !info.active())

        doc->setActiveNode(0);

    else if (!activeNode && newHoverNode && info.active())

        doc->setActiveNode(newHoverNode);

13911355

1392 // Update our current hover node.

13931356 doc->setHoverNode(newHoverNode);

    // We have two different objects.  Fetch their renderers.

    RenderObject* oldHoverObj = oldHoverNode ? oldHoverNode->renderer() : 0;

    RenderObject* newHoverObj = newHoverNode ? newHoverNode->renderer() : 0;

    // Locate the common ancestor render object for the two renderers.

    RenderObject* ancestor = commonAncestor(oldHoverObj, newHoverObj);

    if (oldHoverObj != newHoverObj) {

        // The old hover path only needs to be cleared up to (and not including) the common ancestor;

        for (RenderObject* curr = oldHoverObj; curr && curr != ancestor; curr = curr->hoverAncestor()) {

            if (curr->element() && !curr->isText() && (!mustBeInActiveChain || curr->element()->inActiveChain())) {

                curr->element()->setActive(false);

                curr->element()->setHovered(false);

            }

        }

    }

    // Now set the hover state for our new object up to the root.

    for (RenderObject* curr = newHoverObj; curr; curr = curr->hoverAncestor()) {

        if (curr->element() && !curr->isText() && (!mustBeInActiveChain || curr->element()->inActiveChain())) {

            curr->element()->setActive(info.active());

            curr->element()->setHovered(true);

        }

    }

}

// Helpers for the sorting of layers by z-index.

13191

WebCore/rendering/render_object.h

@@public:

     * positioned elements

     */

    RenderObject *container() const;

336 RenderObject* hoverAncestor() const;

    virtual void markAllDescendantsWithFloatsForLayout(RenderObject* floatToRemove = 0);

    void markContainingBlocksForLayout();

13191

WebCore/rendering/render_object.cpp

@@RenderObject *RenderObject::container()

    return o;

}

// This code has been written to anticipate the addition of CSS3-::outside and ::inside generated

// content (and perhaps XBL).  That's why it uses the render tree and not the DOM tree.

RenderObject* RenderObject::hoverAncestor() const

{

    return (!isInline() && continuation()) ? continuation() : parent();

}

bool RenderObject::isSelectionBorder() const

{

    SelectionState st = selectionState();

    return st == SelectionStart || st == SelectionEnd || st == SelectionBoth;

}

2009

void RenderObject::removeFromObjectLists()

{

    if (isFloating()) {

13191

WebCore/dom/DocumentImpl.h

@@public:

    NodeImpl* hoverNode() const { return m_hoverNode.get(); }

    void setHoverNode(PassRefPtr<NodeImpl>);

    void hoveredNodeDetached(NodeImpl*);

362 void activeChainNodeDetached(NodeImpl*);

    
    NodeImpl* activeNode() const { return m_activeNode.get(); }

    void setActiveNode(PassRefPtr<NodeImpl>);

    void activeChainNodeDetached(NodeImpl*);

    void trimHoverActiveChainsToRenderTree();

    // Updates for :target (CSS3 selector).

    void setCSSTarget(NodeImpl*);

13191

WebCore/dom/DocumentImpl.cpp

@@void DocumentImpl::recalcStyleSelector()

    m_styleSelectorDirty = false;

}

static NodeImpl* commonAncestor(NodeImpl* node1, NodeImpl* node2)

{

    if (!node1 || !node2)

        return 0;

    for (NodeImpl* currNode1 = node1; currNode1; currNode1 = currNode1->parent())

        for (NodeImpl* currNode2 = node2; currNode2; currNode2 = currNode2->parent())

            if (currNode1 == currNode2)

                return currNode1;

    return 0;

}

19251938void DocumentImpl::setHoverNode(PassRefPtr<NodeImpl> newHoverNode)

19261939{

    NodeImpl* oldHoverNode = m_hoverNode.get();

    for (NodeImpl* curr = newHoverNode.get(); curr; curr = curr->parent()) {

        if (!curr->isTextNode() && (!m_activeNode || curr->inActiveChain())) {

            curr->setHovered(true);

            curr->setActive(m_activeNode);

        }

    }

    NodeImpl* ancestor = commonAncestor(oldHoverNode, newHoverNode.get());

    for (NodeImpl* curr = oldHoverNode; curr != ancestor; curr = curr->parent()) {

        if (!curr->isTextNode() && (!m_activeNode || curr->inActiveChain())) {

            curr->setHovered(false);

            curr->setActive(false);

        }

    }

    m_hoverNode = newHoverNode;

}

void DocumentImpl::setActiveNode(PassRefPtr<NodeImpl> newActiveNode)

{

    NodeImpl* oldActiveNode = m_activeNode.get();

    for (NodeImpl* curr = newActiveNode.get(); curr; curr = curr->parent()) {

        if (!curr->isTextNode())

            curr->setInActiveChain(true);

    }

    NodeImpl* ancestor = commonAncestor(oldActiveNode, newActiveNode.get());

    for (NodeImpl* curr = oldActiveNode; curr != ancestor; curr = curr->parent()) {

        if (!curr->isTextNode())

            curr->setInActiveChain(false);

    }

    m_activeNode = newActiveNode;

}

@@void DocumentImpl::activeChainNodeDetach

        m_activeNode = m_activeNode->parent();

}

void DocumentImpl::trimHoverActiveChainsToRenderTree()

{

    NodeImpl *n;

    for (n = m_hoverNode.get(); n && !n->renderer(); n = n->parent()) {

        if (!n->isTextNode())

            n->setHovered(false);

    }

    m_hoverNode = n;

    for (n = m_activeNode.get(); n && !n->renderer(); n = n->parent()) {

        if (!n->isTextNode()) {

            n->setInActiveChain(false);

            n->setActive(false);

        }

    }

    m_activeNode = n;

}

bool DocumentImpl::relinquishesEditingFocus(NodeImpl *node)

{

    assert(node);

13191

WebCore/dom/dom_elementimpl.cpp

@@void ElementImpl::recalcStyle( StyleChan

        newStyle->ref();

        StyleChange ch = diff( _style, newStyle );

        if (ch == Detach) {

564 if (attached()) detach();

            if (attached()) {

                RefPtr<NodeImpl> hoverNode = getDocument()->hoverNode();

                RefPtr<NodeImpl> activeNode = getDocument()->activeNode();

                detach();

                getDocument()->setActiveNode(activeNode);

                getDocument()->setHoverNode(hoverNode);

            }

565571 // ### Suboptimal. Style gets calculated again.

566572 attach();

573 getDocument()->trimHoverActiveChainsToRenderTree();

            // attach recalulates the style for all children. No need to do it twice.

            setChanged( false );

            setHasChangedChild( false );

13191

WebCore/css/cssstyleselector.cpp

@@bool CSSStyleSelector::checkOneSelector(

                if (strictParsing || isSubSelector || sel->relation() == CSSSelector::SubSelector || (sel->hasTag() && !e->hasTagName(aTag)) || e->isLink()) {

                    if (element == e && style)

                        style->setAffectedByHoverRules(true);

                    if (e->renderer()) {

                        if (element != e)

                            e->renderer()->style()->setAffectedByHoverRules(true);

                        if (e->hovered())

                            return true;

                    }

                    if (e->renderer() && element != e)

                        e->renderer()->style()->setAffectedByHoverRules(true);

                    if (e->hovered())

                        return true;

13191

WebCore/page/FrameView.cpp

@@void FrameView::layoutTimerFired(Timer<F

void FrameView::hoverTimerFired(Timer<FrameView>*)

{

    d->hoverTimer.stop();

1069 m_frame->document()->prepareMouseEvent(false, ~~fal~~se, true, d->prevMouseX, d->prevMouseY, 0);

1069 m_frame->document()->prepareMouseEvent(false, d->mousePressed, true, d->prevMouseX, d->prevMouseY, 0);

}

void FrameView::scheduleRelayout()

13191