void QGraphicsWidgetPrivate::updateFont(const QFont &font)
{
Q_Q(QGraphicsWidget);
// Update the local font setting.
this->font = font;
// Calculate new mask.
if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation))
inheritedFontResolveMask = 0;
int mask = font.resolve() | inheritedFontResolveMask;
// Propagate to children.
for (int i = 0; i < children.size(); ++i) {
QGraphicsItem *item = children.at(i);
if (item->isWidget()) {
QGraphicsWidget *w = static_cast<QGraphicsWidget *>(item);
if (!w->isWindow() || w->testAttribute(Qt::WA_WindowPropagation))
w->d_func()->resolveFont(mask);
} else {
item->d_ptr->resolveFont(mask);
}
}
if (!polished)
return;
// Notify change.
QEvent event(QEvent::FontChange);
QApplication::sendEvent(q, &event);
}
void QGraphicsWidgetPrivate::updatePalette(const QPalette &palette)
{
Q_Q(QGraphicsWidget);
// Update local palette setting.
this->palette = palette;
// Calculate new mask.
if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation))
inheritedPaletteResolveMask = 0;
int mask = palette.resolve() | inheritedPaletteResolveMask;
// Propagate to children.
for (int i = 0; i < children.size(); ++i) {
QGraphicsItem *item = children.at(i);
if (item->isWidget()) {
QGraphicsWidget *w = static_cast<QGraphicsWidget *>(item);
if (!w->isWindow() || w->testAttribute(Qt::WA_WindowPropagation))
w->d_func()->resolvePalette(mask);
} else {
item->d_ptr->resolvePalette(mask);
}
}
// Notify change.
QEvent event(QEvent::PaletteChange);
QApplication::sendEvent(q, &event);
}
/*!
Activates the layout, causing all items in the layout to be immediately
rearranged. This function is based on calling count() and itemAt(), and
then calling setGeometry() on all items sequentially. When activated,
the layout will adjust its geometry to its parent's contentsRect().
The parent will then invalidate any layout of its own.
If called in sequence or recursively, e.g., by one of the arranged items
in response to being resized, this function will do nothing.
Note that the layout is free to use geometry caching to optimize this
process. To forcefully invalidate any such cache, you can call
invalidate() before calling activate().
\sa invalidate()
*/
void QGraphicsLayout::activate()
{
Q_D(QGraphicsLayout);
if (d->activated)
return;
d->activateRecursive(this);
// we don't call activate on a sublayout, but somebody might.
// Therefore, we walk to the parentitem of the toplevel layout.
QGraphicsLayoutItem *parentItem = this;
while (parentItem && parentItem->isLayout())
parentItem = parentItem->parentLayoutItem();
if (!parentItem)
return;
Q_ASSERT(!parentItem->isLayout());
if (QGraphicsLayout::instantInvalidatePropagation()) {
QGraphicsWidget *parentWidget = static_cast<QGraphicsWidget*>(parentItem);
if (!parentWidget->parentLayoutItem()) {
// we've reached the topmost widget, resize it
bool wasResized = parentWidget->testAttribute(Qt::WA_Resized);
parentWidget->resize(parentWidget->size());
parentWidget->setAttribute(Qt::WA_Resized, wasResized);
}
setGeometry(parentItem->contentsRect()); // relayout children
} else {
setGeometry(parentItem->contentsRect()); // relayout children
parentLayoutItem()->updateGeometry();
}
}
void QGraphicsWidgetPrivate::setLayoutDirection_helper(Qt::LayoutDirection direction)
{
Q_Q(QGraphicsWidget);
if ((direction == Qt::RightToLeft) == (testAttribute(Qt::WA_RightToLeft)))
return;
q->setAttribute(Qt::WA_RightToLeft, (direction == Qt::RightToLeft));
// Propagate this change to all children.
for (int i = 0; i < children.size(); ++i) {
QGraphicsItem *item = children.at(i);
if (item->isWidget()) {
QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
if (widget->parentWidget() && !widget->testAttribute(Qt::WA_SetLayoutDirection))
widget->d_func()->setLayoutDirection_helper(direction);
}
}
// Send the notification event to this widget item.
QEvent e(QEvent::LayoutDirectionChange);
QApplication::sendEvent(q, &e);
}