void RenderRegion::attachRegion()
{
if (!m_flowThread)
return;
// By now the flow thread should already be added to the rendering tree,
// so we go up the rendering parents and check that this region is not part of the same
// flow that it actually needs to display. It would create a circular reference.
RenderObject* parentObject = parent();
m_parentNamedFlowThread = 0;
for ( ; parentObject; parentObject = parentObject->parent()) {
if (parentObject->isRenderNamedFlowThread()) {
m_parentNamedFlowThread = toRenderNamedFlowThread(parentObject);
// Do not take into account a region that links a flow with itself. The dependency
// cannot change, so it is not worth adding it to the list.
if (m_flowThread == m_parentNamedFlowThread) {
m_flowThread = 0;
return;
}
break;
}
}
m_flowThread->addRegionToThread(this);
}
static RenderNamedFlowThread* renderNamedFlowThreadContainer(RenderObject* object)
{
while (object && object->isAnonymousBlock() && !object->isRenderNamedFlowThread())
object = object->parent();
return object && object->isRenderNamedFlowThread() ? toRenderNamedFlowThread(object) : 0;
}
void RenderView::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
RenderBlock::styleDidChange(diff, oldStyle);
for (RenderObject* renderer = firstChild(); renderer; renderer = renderer->nextSibling()) {
if (renderer->isRenderNamedFlowThread()) {
RenderNamedFlowThread* flowRenderer = toRenderNamedFlowThread(renderer);
flowRenderer->setStyle(RenderFlowThread::createFlowThreadStyle(style()));
}
}
}
void RenderNamedFlowFragment::checkRegionStyle()
{
ASSERT(m_flowThread);
bool customRegionStyle = false;
// FIXME: Region styling doesn't work for pseudo elements.
if (!isPseudoElement())
customRegionStyle = view().document().ensureStyleResolver().checkRegionStyle(generatingElement());
setHasCustomRegionStyle(customRegionStyle);
toRenderNamedFlowThread(m_flowThread)->checkRegionsWithStyling();
}
void RenderRegion::installFlowThread()
{
m_flowThread = &view().flowThreadController().ensureRenderFlowThreadWithName(style()->regionThread());
// By now the flow thread should already be added to the rendering tree,
// so we go up the rendering parents and check that this region is not part of the same
// flow that it actually needs to display. It would create a circular reference.
RenderObject* parentObject = parent();
m_parentNamedFlowThread = 0;
for ( ; parentObject; parentObject = parentObject->parent()) {
if (parentObject->isRenderNamedFlowThread()) {
m_parentNamedFlowThread = toRenderNamedFlowThread(parentObject);
// Do not take into account a region that links a flow with itself. The dependency
// cannot change, so it is not worth adding it to the list.
if (m_flowThread == m_parentNamedFlowThread)
m_flowThread = 0;
break;
}
}
}
static PassRefPtr<InspectorObject> buildObjectForElementInfo(Node* node)
{
if (!node->isElementNode() || !node->document().frame())
return nullptr;
RefPtr<InspectorObject> elementInfo = InspectorObject::create();
Element* element = toElement(node);
bool isXHTML = element->document().isXHTMLDocument();
elementInfo->setString("tagName", isXHTML ? element->nodeName() : element->nodeName().lower());
elementInfo->setString("idValue", element->getIdAttribute());
HashSet<AtomicString> usedClassNames;
if (element->hasClass() && element->isStyledElement()) {
StringBuilder classNames;
const SpaceSplitString& classNamesString = toStyledElement(element)->classNames();
size_t classNameCount = classNamesString.size();
for (size_t i = 0; i < classNameCount; ++i) {
const AtomicString& className = classNamesString[i];
if (usedClassNames.contains(className))
continue;
usedClassNames.add(className);
classNames.append('.');
classNames.append(className);
}
elementInfo->setString("className", classNames.toString());
}
RenderElement* renderer = element->renderer();
Frame* containingFrame = node->document().frame();
FrameView* containingView = containingFrame->view();
IntRect boundingBox = pixelSnappedIntRect(containingView->contentsToRootView(renderer->absoluteBoundingBoxRect()));
RenderBoxModelObject* modelObject = renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : nullptr;
elementInfo->setString("nodeWidth", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetWidth(), *modelObject) : boundingBox.width()));
elementInfo->setString("nodeHeight", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetHeight(), *modelObject) : boundingBox.height()));
if (renderer->isRenderNamedFlowFragmentContainer()) {
RenderNamedFlowFragment* region = toRenderBlockFlow(renderer)->renderNamedFlowFragment();
if (region->isValid()) {
RenderFlowThread* flowThread = region->flowThread();
ASSERT(flowThread && flowThread->isRenderNamedFlowThread());
RefPtr<InspectorObject> regionFlowInfo = InspectorObject::create();
regionFlowInfo->setString("name", toRenderNamedFlowThread(flowThread)->flowThreadName());
regionFlowInfo->setArray("regions", buildObjectForCSSRegionsHighlight(region, flowThread));
elementInfo->setObject("regionFlowInfo", regionFlowInfo.release());
}
}
RenderFlowThread* containingFlowThread = renderer->flowThreadContainingBlock();
if (containingFlowThread && containingFlowThread->isRenderNamedFlowThread()) {
RefPtr<InspectorObject> contentFlowInfo = InspectorObject::create();
contentFlowInfo->setString("name", toRenderNamedFlowThread(containingFlowThread)->flowThreadName());
elementInfo->setObject("contentFlowInfo", contentFlowInfo.release());
}
#if ENABLE(CSS_SHAPES)
if (renderer->isBox()) {
RenderBox* renderBox = toRenderBox(renderer);
if (RefPtr<InspectorObject> shapeObject = buildObjectForShapeOutside(containingFrame, renderBox))
elementInfo->setObject("shapeOutsideInfo", shapeObject.release());
}
#endif
// Need to enable AX to get the computed role.
if (!WebCore::AXObjectCache::accessibilityEnabled())
WebCore::AXObjectCache::enableAccessibility();
if (AXObjectCache* axObjectCache = node->document().axObjectCache()) {
if (AccessibilityObject* axObject = axObjectCache->getOrCreate(node))
elementInfo->setString("role", axObject->computedRoleString());
}
return elementInfo.release();
}
RenderBlock* RenderNamedFlowThread::fragmentFromRenderBoxAsRenderBlock(RenderBox* renderBox, const IntPoint& absolutePoint, const RenderBox& flowedBox)
{
return toRenderNamedFlowThread(renderBox)->fragmentFromAbsolutePointAndBox(absolutePoint, flowedBox);
}
RenderNamedFlowThread* RenderNamedFlowFragment::namedFlowThread() const
{
return toRenderNamedFlowThread(flowThread());
}
