rSize ruiLinearLayout::LayoutVertical(rRect& rect, bool setPosition){
rSize layoutSize(0, 0);
rSize currentItemSize(0, 0);
ruiWidget* widget = nullptr;
rPoint contentOffset = ContentOffset();
rPoint layoutPos(rect.x + contentOffset.x, rect.y + contentOffset.y);
rIntArray margins(4);
for (size_t i = 0; i < m_layoutItems.size(); i++){
widget = m_layoutItems[i];
DetermineMargins(widget, margins);
rPoint finalPosition = layoutPos;
finalPosition.x += margins[ruiMARGIN_LEFT];
finalPosition.y += margins[ruiMARGIN_TOP];
if (setPosition)
widget->SetPosition(finalPosition);
currentItemSize = widget->Size();
layoutSize.x = std::max(layoutSize.x, currentItemSize.x + margins[ruiMARGIN_LEFT] + margins[ruiMARGIN_RIGHT]);
layoutSize.y += currentItemSize.y + margins[ruiMARGIN_TOP] + margins[ruiMARGIN_BOTTOM];
layoutPos.y += currentItemSize.y + margins[ruiMARGIN_TOP] + margins[ruiMARGIN_BOTTOM];
}
return layoutSize;
}
CString ViewportConfiguration::description() const
{
TextStream ts;
ts.startGroup();
ts << "viewport-configuration " << (void*)this;
{
TextStream::GroupScope scope(ts);
ts << "viewport arguments";
ts << m_viewportArguments;
}
{
TextStream::GroupScope scope(ts);
ts << "configuration";
ts << m_configuration;
}
{
TextStream::GroupScope scope(ts);
ts << "default configuration";
ts << m_defaultConfiguration;
}
ts.dumpProperty("contentSize", m_contentSize);
ts.dumpProperty("minimumLayoutSize", m_minimumLayoutSize);
ts.dumpProperty("computed initial scale", initialScale());
ts.dumpProperty("computed minimum scale", minimumScale());
ts.dumpProperty("computed layout size", layoutSize());
ts.dumpProperty("ignoring horizontal scaling constraints", shouldIgnoreHorizontalScalingConstraints() ? "true" : "false");
ts.dumpProperty("ignoring vertical scaling constraints", shouldIgnoreVerticalScalingConstraints() ? "true" : "false");
ts.endGroup();
return ts.release().utf8();
}
CString ViewportConfiguration::description() const
{
TextStream ts;
ts << "(viewport-configuration " << (void*)this;
ts << "\n";
ts.increaseIndent();
ts.writeIndent();
ts << "(viewport arguments";
ts << m_viewportArguments;
ts << ")";
ts.decreaseIndent();
ts << "\n";
ts.increaseIndent();
ts.writeIndent();
ts << "(configuration";
ts << m_configuration;
ts << ")";
ts.decreaseIndent();
ts << "\n";
ts.increaseIndent();
ts.writeIndent();
ts << "(default configuration";
ts << m_defaultConfiguration;
ts << ")";
ts.decreaseIndent();
ts.dumpProperty("contentSize", m_contentSize);
ts.dumpProperty("minimumLayoutSize", m_minimumLayoutSize);
ts << "\n";
ts.increaseIndent();
ts.writeIndent();
ts << "(computed initial scale " << initialScale() << ")\n";
ts.writeIndent();
ts << "(computed minimum scale " << minimumScale() << ")\n";
ts.writeIndent();
ts << "(computed layout size " << layoutSize() << ")\n";
ts.writeIndent();
ts << "(ignoring horizontal scaling constraints " << (shouldIgnoreHorizontalScalingConstraints() ? "true" : "false") << ")\n";
ts.writeIndent();
ts << "(ignoring vertical scaling constraints " << (shouldIgnoreVerticalScalingConstraints() ? "true" : "false") << ")";
ts.decreaseIndent();
ts << ")\n";
return ts.release().utf8();
}
void paintEvent(QPaintEvent *)
{
QSize layoutSize(75, 75);
QPainter widgetPainter(this);
widgetPainter.fillRect(QRect(QPoint(0, 0), this->size()), Qt::gray);
{
const qreal devicePixelRatio = this->windowHandle()->devicePixelRatio();
QPixmap cache(layoutSize * devicePixelRatio);
cache.setDevicePixelRatio(devicePixelRatio);
QPainter cachedPainter(&cache);
cachedPainter.fillRect(QRect(0,0, 75, 75), Qt::blue);
cachedPainter.fillRect(QRect(10,10, 55, 55), Qt::red);
cachedPainter.drawEllipse(QRect(10,10, 55, 55));
QPainter widgetPainter(this);
widgetPainter.drawPixmap(QPoint(10, 10), cache);
}
{
const qreal devicePixelRatio = this->windowHandle()->devicePixelRatio();
QImage cache = QImage(layoutSize * devicePixelRatio, QImage::Format_ARGB32_Premultiplied);
cache.setDevicePixelRatio(devicePixelRatio);
QPainter cachedPainter(&cache);
cachedPainter.fillRect(QRect(0,0, 75, 75), Qt::blue);
cachedPainter.fillRect(QRect(10,10, 55, 55), Qt::red);
cachedPainter.drawEllipse(QRect(10,10, 55, 55));
QPainter widgetPainter(this);
widgetPainter.drawImage(QPoint(95, 10), cache);
}
}
Vec2f GridLayout::maximumContentsLayoutSize(const MFUnrecChildComponentPtr* Components, const Component* ParentComponent) const
{
return layoutSize(Components, ParentComponent, MAX_SIZE);
}
Vec2f GridLayout::preferredContentsLayoutSize(const MFUnrecChildComponentPtr* Components, const Component* ParentComponent) const
{
return layoutSize(Components, ParentComponent, PREFERRED_SIZE);
}
Vec2f GridLayout::requestedContentsLayoutSize(const MFUnrecChildComponentPtr* Components, const Component* ParentComponent) const
{
return layoutSize(Components, ParentComponent, REQUESTED_SIZE);
}
Vec2f CardLayout::minimumContentsLayoutSize(const MFUnrecChildComponentPtr* Components, const Component* ParentComponent) const
{
return layoutSize(Components, ParentComponent, MIN_SIZE);
}
bool FrameView::wasViewportResized()
{
return layoutSize() != m_lastViewportSize;
}
void FrameView::layout(bool allowSubtree)
{
// We should never layout a Document which is not in a LocalFrame.
ASSERT(m_frame);
ASSERT(m_frame->view() == this);
ScriptForbiddenScope forbidScript;
if (isInPerformLayout() || !m_frame->document()->isActive())
return;
TRACE_EVENT0("blink", "FrameView::layout");
TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "Layout");
// Protect the view from being deleted during layout (in recalcStyle)
RefPtr<FrameView> protector(this);
m_hasPendingLayout = false;
RELEASE_ASSERT(!isPainting());
if (!allowSubtree && isSubtreeLayout()) {
m_layoutSubtreeRoot->markContainingBlocksForLayout(false);
m_layoutSubtreeRoot = 0;
}
performPreLayoutTasks();
// If there is only one ref to this view left, then its going to be destroyed as soon as we exit,
// so there's no point to continuing to layout
if (protector->hasOneRef())
return;
Document* document = m_frame->document();
bool inSubtreeLayout = isSubtreeLayout();
RenderObject* rootForThisLayout = inSubtreeLayout ? m_layoutSubtreeRoot : document->renderView();
if (!rootForThisLayout) {
// FIXME: Do we need to set m_size here?
ASSERT_NOT_REACHED();
return;
}
FontCachePurgePreventer fontCachePurgePreventer;
RenderLayer* layer;
{
TemporaryChange<bool> changeSchedulingEnabled(m_layoutSchedulingEnabled, false);
m_nestedLayoutCount++;
if (!inSubtreeLayout) {
if (m_firstLayout) {
m_firstLayout = false;
m_lastViewportSize = layoutSize();
}
m_size = LayoutSize(layoutSize());
}
layer = rootForThisLayout->enclosingLayer();
performLayout(rootForThisLayout, inSubtreeLayout);
m_layoutSubtreeRoot = 0;
} // Reset m_layoutSchedulingEnabled to its previous value.
layer->updateLayerPositionsAfterLayout();
m_layoutCount++;
ASSERT(!rootForThisLayout->needsLayout());
scheduleOrPerformPostLayoutTasks();
m_nestedLayoutCount--;
if (m_nestedLayoutCount)
return;
#if ENABLE(ASSERT)
// Post-layout assert that nobody was re-marked as needing layout during layout.
document->renderView()->assertSubtreeIsLaidOut();
#endif
}
static int resize(kernelWindowComponent *component, int width, int height)
{
// Calls our internal 'layoutSize' function
return (layoutSize(component, width, height));
}
static int layout(kernelWindowComponent *containerComponent)
{
// Do layout for the container.
int status = 0;
kernelWindowContainer *container = containerComponent->data;
kernelWindowComponent *component = NULL;
int count1, count2;
// Check params
if (!containerComponent)
{
kernelError(kernel_error, "NULL parameter");
return (status = ERR_NULLPARAMETER);
}
if (containerComponent->type != containerComponentType)
{
kernelError(kernel_error, "Component is not a container");
return (status = ERR_INVALID);
}
// For any components that are containers, have them do their layouts first
// so we know their sizes.
for (count1 = 0; count1 < container->numComponents; count1 ++)
{
component = container->components[count1];
if (component->layout)
{
status = component->layout(component);
if (status < 0)
return (status);
}
}
containerComponent->width = 0;
containerComponent->height = 0;
containerComponent->minWidth = 0;
containerComponent->minHeight = 0;
// Call our 'layoutSize' function to do the layout, but don't specify
// any extra size since we want 'minimum' sizes for now
status = layoutSize(containerComponent, 0, 0);
if (status < 0)
return (status);
containerComponent->minWidth = containerComponent->width;
containerComponent->minHeight = containerComponent->height;
// Loop through the container's components, checking to see whether
// each overlaps any others, and if so, decrement their levels
for (count1 = 0; count1 < container->numComponents; count1 ++)
{
component = container->components[count1];
// Check whether this component overlaps any others, and if so,
// decrement their levels
for (count2 = 0; count2 < container->numComponents; count2 ++)
{
if (container->components[count2] != component)
{
if (doAreasIntersect(makeComponentScreenArea(component),
makeComponentScreenArea(container->components[count2])))
container->components[count2]->level++;
}
}
}
// Set the flag to indicate layout complete
containerComponent->doneLayout = 1;
return (status = 0);
}
