void Robot::moveDown() {
if (isFloating()) {
pos.y -= step;
if (isFloating()) {
if (hasBaseColision())
pos.y += step;
} else
checkMovement();
}
}
void RenderLayerModelObject::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
bool hadTransform = hasTransform();
RenderObject::styleDidChange(diff, oldStyle);
updateFromStyle();
LayerType type = layerTypeRequired();
if (type != NoLayer) {
if (!layer() && layerCreationAllowedForSubtree()) {
if (s_wasFloating && isFloating())
setChildNeedsLayout();
createLayer(type);
if (parent() && !needsLayout() && containingBlock()) {
// FIXME: This invalidation is overly broad. We should update to
// do the correct invalidation at RenderStyle::diff time. crbug.com/349061
if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled())
layer()->renderer()->setShouldDoFullPaintInvalidationAfterLayout(true);
else
layer()->repainter().setRepaintStatus(NeedsFullRepaint);
// Hit in animations/interpolation/perspective-interpolation.html
// FIXME: I suspect we can remove this assert disabler now.
DisableCompositingQueryAsserts disabler;
layer()->updateLayerPositionRecursive();
}
}
} else if (layer() && layer()->parent()) {
setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
setHasReflection(false);
layer()->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer
if (s_wasFloating && isFloating())
setChildNeedsLayout();
if (hadTransform)
setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
}
if (layer()) {
// FIXME: Ideally we shouldn't need this setter but we can't easily infer an overflow-only layer
// from the style.
layer()->setLayerType(type);
layer()->styleChanged(diff, oldStyle);
}
if (FrameView *frameView = view()->frameView()) {
bool newStyleIsViewportConstained = style()->hasViewportConstrainedPosition();
bool oldStyleIsViewportConstrained = oldStyle && oldStyle->hasViewportConstrainedPosition();
if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
if (newStyleIsViewportConstained && layer())
frameView->addViewportConstrainedObject(this);
else
frameView->removeViewportConstrainedObject(this);
}
}
}
void RenderLayerModelObject::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
bool hadTransform = hasTransform();
bool hadLayer = hasLayer();
bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer();
RenderObject::styleDidChange(diff, oldStyle);
updateFromStyle();
LayerType type = layerTypeRequired();
if (type != NoLayer) {
if (!layer() && layerCreationAllowedForSubtree()) {
if (s_wasFloating && isFloating())
setChildNeedsLayout();
createLayer(type);
if (parent() && !needsLayout()) {
// FIXME: We should call a specialized version of this function.
layer()->updateLayerPositionsAfterLayout();
}
}
} else if (layer() && layer()->parent()) {
setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
setHasReflection(false);
layer()->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer
if (s_wasFloating && isFloating())
setChildNeedsLayout();
if (hadTransform)
setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
}
if (layer()) {
// FIXME: Ideally we shouldn't need this setter but we can't easily infer an overflow-only layer
// from the style.
layer()->setLayerType(type);
layer()->styleChanged(diff, oldStyle);
if (hadLayer && layer()->isSelfPaintingLayer() != layerWasSelfPainting)
setChildNeedsLayout();
}
if (FrameView *frameView = view()->frameView()) {
bool newStyleIsViewportConstained = style()->hasViewportConstrainedPosition();
bool oldStyleIsViewportConstrained = oldStyle && oldStyle->hasViewportConstrainedPosition();
if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
if (newStyleIsViewportConstained && layer())
frameView->addViewportConstrainedObject(this);
else
frameView->removeViewportConstrainedObject(this);
}
}
}
void RenderLayerModelObject::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
bool hadTransform = hasTransform();
bool hadLayer = hasLayer();
bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer();
RenderObject::styleDidChange(diff, oldStyle);
updateFromStyle();
if (requiresLayer()) {
if (!layer() && layerCreationAllowedForSubtree()) {
if (s_wasFloating && isFloating())
setChildNeedsLayout();
createLayer();
if (parent() && !needsLayout() && containingBlock()) {
layer()->repainter().setRepaintStatus(NeedsFullRepaint);
// There is only one layer to update, it is not worth using |cachedOffset| since
// we are not sure the value will be used.
layer()->updateLayerPositions(0);
}
}
} else if (layer() && layer()->parent()) {
setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
setHasReflection(false);
layer()->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer
if (s_wasFloating && isFloating())
setChildNeedsLayout();
if (hadTransform)
setNeedsLayoutAndPrefWidthsRecalc();
}
if (layer()) {
layer()->styleChanged(diff, oldStyle);
if (hadLayer && layer()->isSelfPaintingLayer() != layerWasSelfPainting)
setChildNeedsLayout();
}
if (FrameView *frameView = view()->frameView()) {
bool newStyleIsViewportConstained = style()->hasViewportConstrainedPosition();
bool oldStyleIsViewportConstrained = oldStyle && oldStyle->hasViewportConstrainedPosition();
if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
if (newStyleIsViewportConstained && layer())
frameView->addViewportConstrainedObject(this);
else
frameView->removeViewportConstrainedObject(this);
}
}
}
RegisterWidget::~RegisterWidget()
{
QSettings settings;
settings.setValue(QStringLiteral("registerwidget/geometry"), saveGeometry());
settings.setValue(QStringLiteral("registerwidget/floating"), isFloating());
}
void TupConfigurationArea::hideConfigurator()
{
QWidget *widget = this->widget();
if (widget && !isFloating ()) {
// widget->setMinimumWidth(10);
widget->setVisible(false);
setFeatures(QDockWidget::NoDockWidgetFeatures);
// =================
QPalette pal = palette();
pal.setBrush(QPalette::Background, pal.button());
setPalette(pal);
setAutoFillBackground(true);
//==================
for (int i = 0; i < 2; ++i)
qApp->processEvents();
shrink();
if (!k->toolTipShowed) {
QToolTip::showText (k->mousePos, tr("Cursor here for expand"), this);
k->toolTipShowed = true;
}
}
k->mousePos = QCursor::pos();
}
/*! \reimp */
void QDockWidget::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event)
QDockWidgetLayout *layout
= qobject_cast<QDockWidgetLayout*>(this->layout());
bool customTitleBar = layout->widgetForRole(QDockWidgetLayout::TitleBar) != 0;
bool nativeDeco = layout->nativeWindowDeco();
if (!nativeDeco && !customTitleBar) {
QStylePainter p(this);
// ### Add PixelMetric to change spacers, so style may show border
// when not floating.
if (isFloating()) {
QStyleOptionFrame framOpt;
framOpt.init(this);
p.drawPrimitive(QStyle::PE_FrameDockWidget, framOpt);
}
// Title must be painted after the frame, since the areas overlap, and
// the title may wish to extend out to all sides (eg. XP style)
QStyleOptionDockWidgetV2 titleOpt;
initStyleOption(&titleOpt);
p.drawControl(QStyle::CE_DockWidgetTitle, titleOpt);
}
}
void VideoDock::fullScreen(bool b)
{
if (b)
{
is_floating = isFloating();
setTitleBarVisible(false);
setFeatures(DockWidget::NoDockWidgetFeatures);
setFloating(false);
if (!isBreeze)
setStyle(&commonStyle);
}
else
{
/* Visualizations on full screen */
QWidget *dockedW = widget();
if (dockedW != &iDW)
{
if (dockedW)
{
unsetCursor(dockedW);
dockedW->setParent(nullptr);
}
setWidget(&iDW);
}
setTitleBarVisible();
setFeatures(DockWidget::AllDockWidgetFeatures);
setFloating(is_floating);
if (!isBreeze)
setStyle(nullptr);
}
}
WatchWidget::~WatchWidget()
{
auto& settings = Settings::GetQSettings();
settings.setValue(QStringLiteral("watchwidget/geometry"), saveGeometry());
settings.setValue(QStringLiteral("watchwidget/floating"), isFloating());
}
virtual bool event(QEvent* e) override
{
switch (e->type())
{
case QEvent::WindowActivate:
active_ = true;
break;
case QEvent::WindowDeactivate:
active_ = false;
break;
case QEvent::FocusIn:
if (visible_)
{
view_->focusInEvent();
}
break;
case QEvent::ActivationChange:
if (isFloating())
{
if (active_)
view_->focusInEvent();
else
view_->focusOutEvent();
}
break;
}
return QDockWidget::event(e);
}
void RenderLayerModelObject::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
{
s_wasFloating = isFloating();
// If our z-index changes value or our visibility changes,
// we need to dirty our stacking context's z-order list.
RenderStyle* oldStyle = style();
if (oldStyle) {
// Do a repaint with the old style first through RenderLayerRepainter.
// RenderObject::styleWillChange takes care of repainting objects without RenderLayers.
if (parent() && diff.needsRepaintLayer()) {
layer()->repainter().repaintIncludingNonCompositingDescendants();
if (oldStyle->hasClip() != newStyle.hasClip()
|| oldStyle->clip() != newStyle.clip())
layer()->clipper().clearClipRectsIncludingDescendants();
} else if (diff.needsFullLayout()) {
if (hasLayer()) {
if (!layer()->hasCompositedLayerMapping() && oldStyle->position() != newStyle.position())
layer()->repainter().repaintIncludingNonCompositingDescendants();
} else if (newStyle.hasTransform() || newStyle.opacity() < 1 || newStyle.hasFilter()) {
// If we don't have a layer yet, but we are going to get one because of transform or opacity,
// then we need to repaint the old position of the object.
paintInvalidationForWholeRenderer();
}
}
}
RenderObject::styleWillChange(diff, newStyle);
}
void TEditableToolbar::resizeEvent(QResizeEvent* event) {
//qDebug() << "resizeEvent:" << objectName()
// << "from" << event->oldSize() << "to" << size()
// << "min" << minimumSizeHint();
QToolBar::resizeEvent(event);
// Fix the dark and uncontrollable ways of Qt's layout engine.
// It looks like that with an orientation change the resize is done first,
// than the orientation changed signal is sent and received by TTImeslider
// changing TTImesliders minimum size and then another resize arrives,
// based on the old minimum size hint from before the orientation change.
// sizeHint() is never called, so can't fix it that way.
if (isFloating() && space_eater && !fixing_size) {
if (orientation() == Qt::Horizontal) {
if (height() > iconSize().height() + fix_size) {
logger()->debug("resizeEvent: fixing height");
fixing_size = true;
resize(width(), iconSize().height() + fix_size);
fixing_size = false;
}
} else if (width() > iconSize().width() + fix_size) {
logger()->debug("resizeEvent: fixing width");
fixing_size = true;
resize(iconSize().width() + fix_size, height());
fixing_size = false;
}
}
if (size_grip) {
size_grip->follow();
}
}
void InviwoDockWidget::keyPressEvent(QKeyEvent *keyEvent) {
if (keyEvent->key() == Qt::Key_Escape && isFloating()) {
hide();
} else {
keyEvent->ignore();
}
QDockWidget::keyPressEvent(keyEvent);
}
void DockWidget::setState(bool edit) {
QDockWidget::DockWidgetFeatures features;
if (edit) {
setAllowedAreas(Qt::AllDockWidgetAreas);
features = QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable;
if (isClosable()) {
features |= QDockWidget::DockWidgetClosable;
}
} else {
setAllowedAreas(Qt::NoDockWidgetArea);
features = QDockWidget::NoDockWidgetFeatures;
if (isFloating()) {
features |= QDockWidget::DockWidgetFloatable;
}
}
setFeatures(features);
setTitleBarWidget(isFloating() || edit ? Q_NULLPTR : m_titleHide);
}
void TransferFunctionPropertyDialog::moveEvent(QMoveEvent* event) {
ivec2 pos = ivec2(event->pos().x(), event->pos().y());
moveEditor(pos);
if (isFloating() && !(getEditorDockStatus()==PropertyEditorWidgetDockStatus::Floating))
setDockStatus(PropertyEditorWidgetDockStatus::Floating);
QWidget::moveEvent(event);
}
int QToolBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 13)
qt_static_metacall(this, _c, _id, _a);
_id -= 13;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< bool*>(_v) = isMovable(); break;
case 1: *reinterpret_cast< Qt::ToolBarAreas*>(_v) = allowedAreas(); break;
case 2: *reinterpret_cast< Qt::Orientation*>(_v) = orientation(); break;
case 3: *reinterpret_cast< QSize*>(_v) = iconSize(); break;
case 4: *reinterpret_cast< Qt::ToolButtonStyle*>(_v) = toolButtonStyle(); break;
case 5: *reinterpret_cast< bool*>(_v) = isFloating(); break;
case 6: *reinterpret_cast< bool*>(_v) = isFloatable(); break;
}
_id -= 7;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setMovable(*reinterpret_cast< bool*>(_v)); break;
case 1: setAllowedAreas(*reinterpret_cast< Qt::ToolBarAreas*>(_v)); break;
case 2: setOrientation(*reinterpret_cast< Qt::Orientation*>(_v)); break;
case 3: setIconSize(*reinterpret_cast< QSize*>(_v)); break;
case 4: setToolButtonStyle(*reinterpret_cast< Qt::ToolButtonStyle*>(_v)); break;
case 6: setFloatable(*reinterpret_cast< bool*>(_v)); break;
}
_id -= 7;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
bool *_b = reinterpret_cast<bool*>(_a[0]);
switch (_id) {
case 0: *_b = (qobject_cast<QMainWindow*>(parentWidget())!=0); break;
case 1: *_b = (qobject_cast<QMainWindow*>(parentWidget())!=0); break;
case 2: *_b = (qobject_cast<QMainWindow*>(parentWidget())==0); break;
}
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 7;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void Robot::moveBack() {
if (pos.x > minX) {
pos.x -= step;
if (isFloating()) {
if (hasBaseColision())
pos.x += step;
} else
if (pos.x < minBaseX)
pos.x = minBaseX;
}
}
void Robot::moveRight() {
if (pos.z < maxZ) {
pos.z += step;
if (isFloating()) {
if (hasBaseColision())
pos.z -= step;
} else
if (pos.z > maxBaseZ)
pos.z = maxBaseZ;
}
}
void Robot::moveFront() {
if (pos.x < maxX) {
pos.x += step;
if (isFloating()) {
if (hasBaseColision())
pos.x -= step;
} else
if (pos.x > maxBaseX)
pos.x = maxBaseX;
}
}
void Robot::moveLeft() {
if (pos.z > minZ) {
pos.z -= step;
if (isFloating()) {
if (hasBaseColision())
pos.z += step;
} else
if (pos.z < minBaseZ)
pos.z = minBaseZ;
}
}
void FlipbookPanel::onMinimizeButtonToggled(bool doMinimize) {
if (!isFloating()) return;
m_flipbook->minimize(doMinimize);
if (doMinimize) {
m_floatingSize = window()->size();
resize(240, 20);
} else {
resize(m_floatingSize);
}
}
const char* RenderGrid::renderName() const
{
if (isFloating())
return "RenderGrid (floating)";
if (isOutOfFlowPositioned())
return "RenderGrid (positioned)";
if (isAnonymous())
return "RenderGrid (generated)";
if (isRelPositioned())
return "RenderGrid (relative positioned)";
return "RenderGrid";
}
RValue Inst::Cmp(int type, RValue lhs, RValue rhs, CodeContext& context)
{
if (CastMatch(context, lhs, rhs))
return RValue();
auto pred = getPredicate(type, lhs.stype(), context);
auto cmpType = lhs.stype()->isVec()? lhs.stype()->subType() : lhs.stype();
auto op = cmpType->isFloating()? Instruction::FCmp : Instruction::ICmp;
auto cmp = CmpInst::Create(op, pred, lhs, rhs, "", context);
auto retType = lhs.stype()->isVec()?
SType::getVec(context, SType::getBool(context), lhs.stype()->size()) :
SType::getBool(context);
return RValue(cmp, retType);
}
const char* RenderMultiColumnBlock::renderName() const
{
if (isFloating())
return "RenderMultiColumnBlock (floating)";
if (isOutOfFlowPositioned())
return "RenderMultiColumnBlock (positioned)";
if (isAnonymousBlock())
return "RenderMultiColumnBlock (anonymous)";
if (isAnonymous())
return "RenderMultiColumnBlock (generated)";
if (isRelPositioned())
return "RenderMultiColumnBlock (relative positioned)";
return "RenderMultiColumnBlock";
}
void TEditableToolbar::addSizeGrip() {
if (space_eater && isFloating()) {
setMaximumSize(0.9 * TDesktop::availableSize(this));
if (!size_grip) {
size_grip = new TSizeGrip(main_window, this);
connect(size_grip, SIGNAL(saveSizeHint()),
space_eater, SLOT(saveSizeHint()));
}
} else {
setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
removeSizeGrip();
}
}
void RenderLayerModelObject::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
{
s_wasFloating = isFloating();
if (RenderStyle* oldStyle = style()) {
if (parent() && diff.needsPaintInvalidationLayer()) {
if (oldStyle->hasAutoClip() != newStyle.hasAutoClip()
|| oldStyle->clip() != newStyle.clip())
layer()->clipper().clearClipRectsIncludingDescendants();
}
}
RenderObject::styleWillChange(diff, newStyle);
}
void RenderLayerModelObject::styleWillChange(StyleDifference diff, const RenderStyle* newStyle)
{
s_wasFloating = isFloating();
s_hadLayer = hasLayer();
s_hadTransform = hasTransform();
if (s_hadLayer)
s_layerWasSelfPainting = layer()->isSelfPaintingLayer();
// If our z-index changes value or our visibility changes,
// we need to dirty our stacking context's z-order list.
RenderStyle* oldStyle = style();
if (oldStyle && newStyle) {
if (parent()) {
// Do a repaint with the old style first, e.g., for example if we go from
// having an outline to not having an outline.
if (diff == StyleDifferenceRepaintLayer) {
layer()->repaintIncludingDescendants();
if (!(oldStyle->clip() == newStyle->clip()))
layer()->clearClipRectsIncludingDescendants();
} else if (diff == StyleDifferenceRepaint || newStyle->outlineSize() < oldStyle->outlineSize())
repaint();
}
if (diff == StyleDifferenceLayout || diff == StyleDifferenceSimplifiedLayout) {
// When a layout hint happens, we go ahead and do a repaint of the layer, since the layer could
// end up being destroyed.
if (hasLayer()) {
if (oldStyle->position() != newStyle->position()
|| oldStyle->zIndex() != newStyle->zIndex()
|| oldStyle->hasAutoZIndex() != newStyle->hasAutoZIndex()
|| !(oldStyle->clip() == newStyle->clip())
|| oldStyle->hasClip() != newStyle->hasClip()
|| oldStyle->opacity() != newStyle->opacity()
|| oldStyle->transform() != newStyle->transform()
#if ENABLE(CSS_FILTERS)
|| oldStyle->filter() != newStyle->filter()
#endif
)
layer()->repaintIncludingDescendants();
} else if (newStyle->hasTransform() || newStyle->opacity() < 1 || newStyle->hasFilter()) {
// If we don't have a layer yet, but we are going to get one because of transform or opacity,
// then we need to repaint the old position of the object.
repaint();
}
}
}
RenderObject::styleWillChange(diff, newStyle);
}
bool ViewSwitcherDockWidget::event(QEvent *event)
{
bool result = FDockWidget::event(event);
if (isFloating()) {
switch (event->type()) {
case QEvent::MouseButtonRelease:
calcWithin();
break;
default:
break;
}
}
return result;
}
const char* RenderMultiColumnBlock::renderName() const
{
if (isFloating())
return "RenderMultiColumnBlock (floating)";
if (isOutOfFlowPositioned())
return "RenderMultiColumnBlock (positioned)";
if (isAnonymousBlock())
return "RenderMultiColumnBlock (anonymous)";
// FIXME: Temporary hack while the new generated content system is being implemented.
if (isPseudoElement())
return "RenderMultiColumnBlock (generated)";
if (isAnonymous())
return "RenderMultiColumnBlock (generated)";
if (isRelPositioned())
return "RenderMultiColumnBlock (relative positioned)";
return "RenderMultiColumnBlock";
}
void LogConfigWidget::SaveSettings()
{
if (m_block_save)
return;
QSettings settings;
settings.setValue(QStringLiteral("logconfigwidget/geometry"), saveGeometry());
settings.setValue(QStringLiteral("logconfigwidget/floating"), isFloating());
// Config - Verbosity
int verbosity = 1;
if (m_verbosity_notice->isChecked())
verbosity = 1;
if (m_verbosity_error->isChecked())
verbosity = 2;
if (m_verbosity_warning->isChecked())
verbosity = 3;
if (m_verbosity_info->isChecked())
verbosity = 4;
// Config - Verbosity
LogManager::GetInstance()->SetLogLevel(static_cast<LogTypes::LOG_LEVELS>(verbosity));
// Config - Outputs
LogManager::GetInstance()->EnableListener(LogListener::FILE_LISTENER, m_out_file->isChecked());
LogManager::GetInstance()->EnableListener(LogListener::CONSOLE_LISTENER,
m_out_console->isChecked());
LogManager::GetInstance()->EnableListener(LogListener::LOG_WINDOW_LISTENER,
m_out_window->isChecked());
// Config - Log Types
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i)
{
const auto type = static_cast<LogTypes::LOG_TYPE>(i);
bool enabled = m_types_list->item(i)->checkState() == Qt::Checked;
bool was_enabled = LogManager::GetInstance()->IsEnabled(type);
if (enabled != was_enabled)
LogManager::GetInstance()->SetEnable(type, enabled);
}
}
