QVariant MapObjectItem::itemChange(GraphicsItemChange change,
const QVariant &value)
{
if (!mSyncing) {
MapRenderer *renderer = mMapDocument->renderer();
if (change == ItemPositionChange
&& (QApplication::keyboardModifiers() & Qt::ControlModifier))
{
const QPointF pixelDiff = value.toPointF() - mOldItemPos;
const QPointF newPixelPos =
renderer->tileToPixelCoords(mOldObjectPos) + pixelDiff;
// Snap the position to the grid
const QPointF newTileCoords =
renderer->pixelToTileCoords(newPixelPos).toPoint();
return renderer->tileToPixelCoords(newTileCoords);
}
else if (change == ItemPositionHasChanged) {
// Update the position of the map object
const QPointF pixelDiff = value.toPointF() - mOldItemPos;
const QPointF newPixelPos =
renderer->tileToPixelCoords(mOldObjectPos) + pixelDiff;
mObject->setPosition(renderer->pixelToTileCoords(newPixelPos));
}
}
return QGraphicsItem::itemChange(change, value);
}
QVariant ResizeHandle::itemChange(GraphicsItemChange change,
const QVariant &value)
{
if (!mMapObjectItem->mSyncing) {
MapRenderer *renderer = mMapObjectItem->mapDocument()->renderer();
if (change == ItemPositionChange) {
// Calculate the absolute pixel position
const QPointF itemPos = mMapObjectItem->pos();
QPointF pixelPos = value.toPointF() + itemPos;
// Calculate the new coordinates in tiles
QPointF tileCoords = renderer->pixelToTileCoords(pixelPos);
const QPointF objectPos = mMapObjectItem->mapObject()->position();
tileCoords -= objectPos;
tileCoords.setX(qMax(tileCoords.x(), qreal(0)));
tileCoords.setY(qMax(tileCoords.y(), qreal(0)));
if (QApplication::keyboardModifiers() & Qt::ControlModifier)
tileCoords = tileCoords.toPoint();
tileCoords += objectPos;
return renderer->tileToPixelCoords(tileCoords) - itemPos;
}
else if (change == ItemPositionHasChanged) {
// Update the size of the map object
const QPointF newPos = value.toPointF() + mMapObjectItem->pos();
QPointF tileCoords = renderer->pixelToTileCoords(newPos);
tileCoords -= mMapObjectItem->mapObject()->position();
mMapObjectItem->resize(QSizeF(tileCoords.x(), tileCoords.y()));
}
}
return QGraphicsItem::itemChange(change, value);
}
QVariant EqHandle::itemChange( QGraphicsItem::GraphicsItemChange change, const QVariant &value )
{
if( change == ItemPositionChange )
{
// pass filter don't move in y direction
if ( m_type == highpass || m_type == lowpass )
{
float newX = value.toPointF().x();
if( newX < 0 )
{
newX = 0;
}
if( newX > m_width )
{
newX = m_width;
}
return QPointF(newX, m_heigth/2);
}
}
QPointF newPos = value.toPointF();
QRectF rect = QRectF( 0, 0, m_width, m_heigth );
if( !rect.contains( newPos ) )
{
// Keep the item inside the scene rect.
newPos.setX( qMin( rect.right(), qMax( newPos.x(), rect.left() ) ) );
newPos.setY( qMin( rect.bottom(), qMax( newPos.y(), rect.top() ) ) );
return newPos;
}
return QGraphicsItem::itemChange( change, value );
}
QVariant TrajectoriesProxyModel::data(const QModelIndex &proxyIndex, int role) const
{
if (role != Qt::DisplayRole ||
!proxyIndex.isValid() ||
!_parentIndex.isValid()) {
return QVariant();
}
if (!proxyIndex.parent().isValid()) {
return proxyIndex.column() == 0? tr("Trajectory %1").arg(proxyIndex.row()) : QVariant();
}
QVariant data = mapToSource(proxyIndex).data();
switch (proxyIndex.column()) {
case VideoModel::LFrameColumn:
return data;
case VideoModel::PositionColumn:
return tr("(%1, %2)").arg(data.toPointF().x()).arg(data.toPointF().y());
case VideoModel::LSpeedColumn:
case VideoModel::LAccelerationColumn:
return QLineF(QPointF(0, 0), data.toPointF()).length();
default:
return QVariant();
}
}
QVariant GraphicsClientItem::itemChange(GraphicsItemChange change, const QVariant &value)
{
if (change == QGraphicsItem::ItemPositionHasChanged) {
if (jackClient) {
jackClient->setClientItemPosition(value.toPointF());
} else {
clientItemsClient->setClientItemPositionByName(clientName, value.toPointF());
}
}
return QGraphicsPathItem::itemChange(change, value);
}
QVariant MeshGraphItemVelocityHandle::itemChange(GraphicsItemChange change, const QVariant &value)
{
switch (change)
{
case QGraphicsItem::ItemPositionHasChanged:
m_station->setVelocity(value.toPointF());
m_arrow->setEdges(QPointF(0, 0), value.toPointF());
m_station->stationChanged();
updateText();
break;
default:
break;
};
return QGraphicsItem::itemChange(change, value);
}
/**
* @brief itemChange handle detail change.
* @param change change
* @param value value
* @return new value.
*/
QVariant VToolDetail::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
{
if (change == ItemPositionHasChanged && scene())
{
// value - this is new position.
QPointF newPos = value.toPointF();
MoveDetail *moveDet = new MoveDetail(doc, newPos.x(), newPos.y(), id, this->scene());
connect(moveDet, &MoveDetail::NeedLiteParsing, doc, &VPattern::LiteParseTree);
qApp->getUndoStack()->push(moveDet);
}
if (change == QGraphicsItem::ItemSelectedChange)
{
if (value == true)
{
// do stuff if selected
this->setFocus();
}
else
{
// do stuff if not selected
}
}
return QGraphicsItem::itemChange(change, value);
}
/*!
\internal
Reimplemented from QGraphicsItemPrivate. ### Qt 5: Move impl to
reimplementation QGraphicsProxyWidget::inputMethodQuery().
*/
QVariant QGraphicsProxyWidgetPrivate::inputMethodQueryHelper(Qt::InputMethodQuery query) const
{
Q_Q(const QGraphicsProxyWidget);
if (!widget || !q->hasFocus())
return QVariant();
QWidget *focusWidget = widget->focusWidget();
if (!focusWidget)
focusWidget = widget;
QVariant v = focusWidget->inputMethodQuery(query);
QPointF focusWidgetPos = q->subWidgetRect(focusWidget).topLeft();
switch (v.type()) {
case QVariant::RectF:
v = v.toRectF().translated(focusWidgetPos);
break;
case QVariant::PointF:
v = v.toPointF() + focusWidgetPos;
break;
case QVariant::Rect:
v = v.toRect().translated(focusWidgetPos.toPoint());
break;
case QVariant::Point:
v = v.toPoint() + focusWidgetPos.toPoint();
break;
default:
break;
}
return v;
}
void PointFComposedProperty::setValue(Property *property,
const QVariant &value, bool rememberOldValue)
{
const QPointF p( value.toPointF() );
property->child("x")->setValue(p.x(), rememberOldValue, false);
property->child("y")->setValue(p.y(), rememberOldValue, false);
}
QVariant SceneItem::itemChange(GraphicsItemChange change, const QVariant& value) {
if (scene() && change == QGraphicsItem::ItemPositionChange) {
QPointF newPos = value.toPointF();
// rect is adjusted so that items cannot be placed one tile to the right/bottom
int adjust = -TILE_SIZE;
QRectF rect = scene()->sceneRect().adjusted(0, 0, adjust, adjust);
if (!rect.contains(newPos)) {
// don't allow the item to be moved outside the scene
newPos.setX(qMin(rect.right(), qMax(newPos.x(), rect.left())));
newPos.setY(qMin(rect.bottom(), qMax(newPos.y(), rect.top())));
}
newPos.setX(round(newPos.x() / TILE_SIZE) * TILE_SIZE);
newPos.setY(round(newPos.y() / TILE_SIZE) * TILE_SIZE);
return newPos;
} else if (change == QGraphicsItem::ItemPositionHasChanged) {
// update the position of the sprite/exit (or whatever) based on the new position
// TODO: generate undo/redo actions for movement somehow
this->updateObject();
return value;
}
return QGraphicsItem::itemChange(change, value);
}
QVariant QBayesNode::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
{
switch (change) {
case QGraphicsItem::ItemSelectedChange:
mIsSelected = value.toBool();
if (mIsSelected)
setFocus();
break;
case QGraphicsItem::ItemPositionChange:
{
if (scene()) {
// value is the new position.
QPointF newPos = value.toPointF();
QRectF sceneRect = scene()->sceneRect();
if (!sceneRect.contains(newPos)) {
// Keep the item inside the scene rect.
newPos.setX(qMin(sceneRect.right(), qMax(newPos.x(), sceneRect.left())));
newPos.setY(qMin(sceneRect.bottom(), qMax(newPos.y(), sceneRect.top())));
}
emit positionChanged(newPos);
update();
return QGraphicsItem::itemChange(change, newPos);
}
break;
}
default:
break;
}
return QGraphicsItem::itemChange(change, value);
}
QVariant Component::itemChange(GraphicsItemChange change,
const QVariant &value) {
if (change == ItemPositionChange && scene()) {
int i = 0;
// QList<Connection *> connectionlist = scene->getConnections();
// qDebug() << "connections are " + QString::number(m);
// foreach (Connection *connection, connections)
// {
// connection->updatePosition();
// qDebug() << i++;
// }
}
if (change == ItemPositionChange && scene()) {
// value is the new position.
QPointF newPos = value.toPointF();
QRectF rect = scene()->sceneRect();
if (!rect.contains(newPos)) {
// Keep the item inside the scene rect.
newPos.setX(qMin(rect.right(), qMax(newPos.x(), rect.left())));
newPos.setY(qMin(rect.bottom(), qMax(newPos.y(), rect.top())));
return newPos;
}
}
return QGraphicsItem::itemChange(change, value);
}
void RefactoringApplier::changeElementInModel(const Id &changeFromId, const Id &changeToId)
{
if (mLogicalModelApi.isLogicalId(changeFromId)) {
return;
}
if (!refactoringElements.contains(changeToId.element())) {
IdList const inLinks = mGraphicalModelApi.mutableGraphicalRepoApi().incomingLinks(changeFromId);
IdList const outLinks = mGraphicalModelApi.mutableGraphicalRepoApi().outgoingLinks(changeFromId);
Id const parentId = mGraphicalModelApi.mutableGraphicalRepoApi().parent(changeFromId);
QVariant const position = mGraphicalModelApi.mutableGraphicalRepoApi().position(changeFromId);
bool const isFromLogicalModel = false;
QString const refactoringsMetamodel = "RefactoringsMetamodel";
QString newEditor = changeToId.editor();
newEditor.chop(refactoringsMetamodel.length());
Id const newId = Id(newEditor, changeToId.diagram(), changeToId.element(), QUuid::createUuid().toString());
Id const newElementId = mGraphicalModelApi.createElement(parentId, newId
, isFromLogicalModel, "ololo", position.toPointF());
for (Id idLink : inLinks) {
mGraphicalModelApi.mutableGraphicalRepoApi().setTo(idLink, newElementId);
}
for (Id idLink : outLinks) {
mGraphicalModelApi.mutableGraphicalRepoApi().setFrom(idLink, newElementId);
}
mGraphicalModelApi.mutableGraphicalRepoApi().removeChild(parentId, changeFromId);
mGraphicalModelApi.mutableGraphicalRepoApi().removeElement(changeFromId);
}
}
void Mapper::setValue(QtProperty* property, const QVariant& value)
{
if (property == _opacityItem)
{
double opacity = qBound(value.toDouble() / 100.0, 0.0, 1.0);
if (opacity != _mapping->getRawOpacity())
{
_mapping->setRawOpacity(opacity);
emit valueChanged();
}
}
else
{
std::map<QtProperty*, std::pair<MShape*, int> >::iterator it = _propertyToVertex.find(property);
if (it != _propertyToVertex.end())
{
const QPointF& p = value.toPointF();
MShape* shape = it->second.first;
int v = it->second.second;
if (shape->getVertex(v) != p)
{
shape->setVertex(v, p);
emit valueChanged();
}
}
}
}
QVariant KWidget::itemChange( GraphicsItemChange change, const QVariant & value )
{
if(change == QGraphicsItem::ItemParentHasChanged
|| change == QGraphicsItem::ItemParentChange)
{
clearThemeCheckFlag();
}
else if(change == QGraphicsItem::ItemScenePositionHasChanged)
{
emit scenePosition(value.toPointF());
}
else if(change == QGraphicsItem::ItemVisibleHasChanged)
{
bool bvis = isVisible();
visibleEvent(bvis);
if(bvis)
{
showEvent();
}
else
{
hideEvent();
}
}
return QGraphicsWidget::itemChange(change, value);
}
QVariant GraphicEQFilterGUIItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value)
{
QVariant result = QGraphicsItem::itemChange(change, value);
if (change == ItemScenePositionHasChanged)
{
GraphicEQFilterGUIScene* s = qobject_cast<GraphicEQFilterGUIScene*>(scene());
s->itemMoved(index);
}
else if (change == ItemSelectedHasChanged)
{
GraphicEQFilterGUIScene* s = qobject_cast<GraphicEQFilterGUIScene*>(scene());
s->itemSelectionChanged(index, value.toBool());
}
else if (change == ItemPositionChange)
{
GraphicEQFilterGUIScene* s = qobject_cast<GraphicEQFilterGUIScene*>(scene());
if (s->getBandCount() != -1)
{
QPointF newPos = value.toPointF();
newPos.setX(s->hzToX(getHz()));
result = newPos;
}
}
return result;
}
bool InspectorBase::isDefault(const InspectorItem& ii)
{
Element* e = inspector->element();
for (int i = 0; i < ii.parent; ++i)
e = e->parent();
P_ID id = ii.t;
P_TYPE t = propertyType(id);
QVariant val = getValue(ii);
QVariant def = e->propertyDefault(id);
if (t == P_TYPE::SIZE || t == P_TYPE::SCALE || t == P_TYPE::SIZE_MM) {
QSizeF sz = def.toSizeF();
qreal v = ii.sv == 0 ? sz.width() : sz.height();
return val.toDouble() == v;
}
if (t == P_TYPE::POINT || t == P_TYPE::POINT_MM) {
QPointF sz = def.toPointF();
qreal v = ii.sv == 0 ? sz.x() : sz.y();
return val.toDouble() == v;
}
if (t == P_TYPE::FRACTION) {
Fraction f = def.value<Fraction>();
int v = ii.sv == 0 ? f.numerator() : f.denominator();
return val.toInt() == v;
}
return val == def;
}
/*!
*/
bool HsContentService::addWidget(const QString &uri, const QVariantHash &preferences,
const QVariant &homescreenData)
{
HsWidgetData data;
data.uri = uri;
HsWidgetHost *widget = HsWidgetHost::createInstance(data, preferences);
if (!widget) {
return false;
}
HsPage *page = HsScene::instance()->activePage();
QPointF touchPoint = homescreenData.toPointF();
if (!page->addNewWidget(widget, touchPoint)) {
widget->remove();
return false;
}
connect(widget,SIGNAL(event_faulted()),SLOT(widgetStartFaulted()));
mWidgetStartFaulted = false;
widget->startWidget(false); // synchronous operation
if (mWidgetStartFaulted) {
// page will destroy widget instance
return false;
}
widget->disconnect(this);
emit widgetAdded(uri, preferences);
return true;
}
//----------------------------------------------------------------------------------------------
QVariant CustomProxy::itemChange(GraphicsItemChange change, const QVariant &value)
{
// handle positioning
if (change == ItemPositionChange && scene())
{
QRectF rect = boundingRect();
QPointF pos = value.toPointF();
QRectF sceneRect = scene()->sceneRect();
if (pos.x() + rect.left() < sceneRect.left()) pos.setX(sceneRect.left() - rect.left());
else if (pos.x() + rect.right() >= sceneRect.right()) pos.setX(sceneRect.right() - rect.right());
if (pos.y() + rect.top() < sceneRect.top()) pos.setY(sceneRect.top() - rect.top());
else if (pos.y() + rect.bottom() >= sceneRect.bottom()) pos.setY(sceneRect.bottom() - rect.bottom());
return pos;
}
// handle popups
//if (change == ItemChildAddedChange || change == ItemChildRemovedChange) {
// if (change == ItemChildAddedChange) {
// currentPopup = qVariantValue<QGraphicsItem *>(value);
// currentPopup->setCacheMode(ItemCoordinateCache);
// if (scene())
// currentPopup->installSceneEventFilter(this);
// } else if (scene()) {
// currentPopup->removeSceneEventFilter(this);
// currentPopup = 0;
// }
//} else if (currentPopup && change == ItemSceneHasChanged) {
// currentPopup->installSceneEventFilter(this);
//}
return QGraphicsProxyWidget::itemChange(change, value);
}
QVariant Container::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
{
if (change == ItemPositionChange) {
QPointF newPos = value.toPointF();
QPointF rigthBottom = QPointF(newPos.x()+this->rect().width(),newPos.y()+this->rect().height());
if (!margins.contains(newPos) || !margins.contains(rigthBottom)) {
newPos.setX(qMin(margins.right(), qMax(newPos.x(), margins.left()+1)));
newPos.setY(qMin(margins.bottom(), qMax(newPos.y(), margins.top()+1)));
if(!margins.contains(rigthBottom))
{
newPos.setX(qMax(margins.left(), qMin(newPos.x(),margins.right()-this->rect().width())));
newPos.setY(qMax(margins.top(), qMin(newPos.y(),margins.bottom()-this->rect().height())));
}
return newPos;
}
emit moved(this);
}
else if(change == ItemSelectedChange)
{
bool b = value.toBool();
if(b)
this->grabKeyboard();
else
this->ungrabKeyboard();
}
return QGraphicsItem::itemChange(change, value);
}
InformationName NodeInstance::setInformation(InformationName name, const QVariant &information, const QVariant &secondInformation, const QVariant &thirdInformation)
{
switch (name) {
case Size: return setInformationSize(information.toSizeF());
case BoundingRect: return setInformationBoundingRect(information.toRectF());
case ContentItemBoundingRect: return setInformationContentItemBoundingRect(information.toRectF());
case Transform: return setInformationTransform(information.value<QTransform>());
case ContentTransform: return setInformationContentTransform(information.value<QTransform>());
case ContentItemTransform: return setInformationContentItemTransform(information.value<QTransform>());
case PenWidth: return setInformationPenWith(information.toInt());
case Position: return setInformationPosition(information.toPointF());
case IsInLayoutable: return setInformationIsInLayoutable(information.toBool());
case SceneTransform: return setInformationSceneTransform(information.value<QTransform>());
case IsResizable: return setInformationIsResizable(information.toBool());
case IsMovable: return setInformationIsMovable(information.toBool());
case IsAnchoredByChildren: return setInformationIsAnchoredByChildren(information.toBool());
case IsAnchoredBySibling: return setInformationIsAnchoredBySibling(information.toBool());
case HasContent: return setInformationHasContent(information.toBool());
case HasAnchor: return setInformationHasAnchor(information.toByteArray(), secondInformation.toBool());break;
case Anchor: return setInformationAnchor(information.toByteArray(), secondInformation.toByteArray(), thirdInformation.value<qint32>());
case InstanceTypeForProperty: return setInformationInstanceTypeForProperty(information.toByteArray(), secondInformation.toByteArray());
case HasBindingForProperty: return setInformationHasBindingForProperty(information.toByteArray(), secondInformation.toBool());
case NoName:
default: break;
}
return NoInformationChange;
}
void QKineticScroller::setScrollMetric(ScrollMetric metric, const QVariant &value)
{
Q_D(QKineticScroller);
switch (metric) {
case DragVelocitySmoothingFactor: d->dragVelocitySmoothingFactor = qBound(qreal(0), value.toReal(), qreal(1)); break;
case LinearDecelerationFactor: d->linearDecelerationFactor = qBound(qreal(0), value.toReal(), qreal(1)); break;
case ExponentialDecelerationBase: d->exponentialDecelerationBase = qBound(qreal(0), value.toReal(), qreal(1)); break;
case OvershootSpringConstant: d->overshootSpringConstantRoot = qSqrt(value.toReal()); break;
case OvershootDragResistanceFactor: d->overshootDragResistanceFactor = value.toReal(); break;
case OvershootMaximumDistance: d->overshootMaximumDistance = value.toPointF(); break;
case DragStartDistance: d->dragStartDistance = value.toReal(); break;
case DragStartDirectionErrorMargin: d->dragStartDirectionErrorMargin = value.toReal(); break;
case MinimumVelocity: d->minimumVelocity = value.toReal(); break;
case MaximumVelocity: d->maximumVelocity = value.toReal(); break;
case MaximumNonAcceleratedVelocity: d->maximumNonAcceleratedVelocity = value.toReal(); break;
case MaximumClickThroughVelocity: d->maximumClickThroughVelocity = value.toReal(); break;
case AxisLockThreshold: d->axisLockThreshold = qBound(qreal(0), value.toReal(), qreal(1)); break;
case FramesPerSecond: d->framesPerSecond = qBound(1, value.toInt(), 100); break;
case FastSwipeMaximumTime: d->fastSwipeMaximumTime = value.toReal(); break;
case FastSwipeMinimumVelocity: d->fastSwipeMinimumVelocity = value.toReal(); break;
case FastSwipeBaseVelocity: d->fastSwipeBaseVelocity = value.toReal(); break;
case ScrollMetricCount: break;
}
}
QString PointFDelegate::displayText( const QVariant& value ) const
{
const QPointF p(value.toPointF());
return QString::fromLatin1(POINTFEDIT_MASK)
.arg(p.x())
.arg(p.y());
}
bool PunchFilter::setOption(int option, const QVariant &value)
{
bool bOK = true;
switch (option) {
case QtImageFilter::Radius:
{
double radius = value.toDouble(&bOK);
if (bOK) m_Radius = radius;
}
break;
case QtImageFilter::Center:
{
QPointF center = value.toPointF();
if (center.isNull()) {
bOK = false;
} else {
m_Center = center;
}
}
break;
case QtImageFilter::Force:
{
double force = value.toDouble(&bOK);
if (bOK) m_Force = force;
}
break;
default:
bOK = false;
break;
}
return bOK;
}
// --------------------------------------------------------------------------------------------------------------------------------------
QVariant CSizeGrip::itemChange(GraphicsItemChange change, const QVariant &value)
{
switch(change)
{
case QGraphicsItem::ItemPositionChange:
{
QPointF nextPos = value.toPointF();
QPointF targetPos = pos() - nextPos;
QSizeF resultSize = gWindow()->size() - QSizeF(targetPos.x(), targetPos.y());
if(resultSize.width() < gWindow()->minSize().width())
{
resultSize.setWidth(gWindow()->minSize().width());
nextPos.setX(pos().x());
}
if(resultSize.height() < gWindow()->minSize().height())
{
resultSize.setHeight(gWindow()->minSize().height());
nextPos.setY(pos().y());
}
gWindow()->setSize(resultSize);
return nextPos;
}
break;
default: return QGraphicsItem::itemChange(change, value);
}
return QGraphicsItem::itemChange(change, value);
}
QVariant MainElement::itemChange(GraphicsItemChange change, const QVariant &value)
{
if (change == ItemPositionChange && scene())
{
QPointF newPos = value.toPointF();
if(newPos.x()<0)
{
newPos.setX(0);
}
if(newPos.y()<0)
{
newPos.setY(0);
}
if(QApplication::mouseButtons() == Qt::LeftButton)
{
int gridSize = STEP_GRID;
qreal xV = round(newPos.x()/gridSize)*gridSize;
qreal yV = round(newPos.y()/gridSize)*gridSize;
this->scene()->update(this->scene()->sceneRect());
return QPointF(xV, yV);
}
else
return newPos;
}
else
return QGraphicsItem::itemChange(change, value);
}
QVariant FretboardAxis::itemChange(GraphicsItemChange change, const QVariant& value)
{
if (change == ItemSelectedChange)
{
const QColor penColor = (value.toBool() ? m_selectionColor : m_defaultColor);
QPen pen = this->pen();
pen.setColor(penColor);
setPen(pen);
}
else if (change == ItemPositionChange)
{
QPointF newPos = value.toPointF();
FretboardEditScene* scene = getScene();
if (scene->isInFretMode())
newPos.setY(scenePos().y());
else if (scene->isInStringMode())
newPos.setX(scenePos().x());
return newPos;
}
else if (change == ItemSceneHasChanged)
{
QGraphicsScene* scene = value.value<QGraphicsScene*>();
if (scene == nullptr)
{
QApplication::restoreOverrideCursor();
}
}
return QGraphicsLineItem::itemChange(change, value);
}
QVariant PixmapItem::itemChange(GraphicsItemChange change,
const QVariant &value)
{
if (change == ItemPositionChange)
{
// value is the new position.
QPointF newPos = value.toPointF();
QRectF rect = parentItem()->boundingRect();
rect.moveLeft(boundingRect().width()*3/4*-1);
rect.setWidth(rect.width() + boundingRect().width()*2/4 );
rect.moveTop(boundingRect().height()*3/4*-1);
rect.setHeight(rect.height() + boundingRect().height()*2/4 );
CardItem *card = qgraphicsitem_cast<CardItem *>(parentItem());
if (!rect.contains(newPos))
{
// Keep the item inside the scene rect.
int newX = (int)qMin(rect.right(), qMax(newPos.x(), rect.left()));
int newY = (int)qMin(rect.bottom(), qMax(newPos.y(), rect.top()));
if(card->isAlign())
{
int gridSize = card->getGridSize();
newX = (newX/(10*gridSize))*(10*gridSize);
newY = (newY/(10*gridSize))*(10*gridSize);
}
newPos.setX(newX);
newPos.setY(newY);
return newPos;
}
else
{
int newX = newPos.x();
int newY = newPos.y();
if(card->isAlign())
{
int gridSize = card->getGridSize();
newX = newPos.x()/(10*gridSize);
newX = newX * (10*gridSize);
newY = newPos.y()/(10*gridSize);
newY = newY*(10*gridSize);
}
newPos.setX(newX);
newPos.setY(newY);
return newPos;
}
}
return QGraphicsItem::itemChange(change, value);
}
QVariant QNodeItem::itemChange(GraphicsItemChange Change, const QVariant& Value)
{
QPointF NewScenePoint = Value.toPointF();
if (!m_SuspendUpdate && Change == QGraphicsItem::ItemPositionChange)
{
const float Width = m_pTransferFunctionItem->rect().width();
const float Height = m_pTransferFunctionItem->rect().height();
QPointF NodeRangeMin = QPointF(m_pNode->GetMinX() * Width, m_pNode->GetMinY() * Height);
QPointF NodeRangeMax = QPointF(m_pNode->GetMaxX() * Width, m_pNode->GetMaxY() * Height);
NewScenePoint.setX(qMin(NodeRangeMax.x() - NODE_POSITION_EPSILON, qMax(NewScenePoint.x(), NodeRangeMin.x() + NODE_POSITION_EPSILON)));
NewScenePoint.setY(qMin(NodeRangeMax.y(), qMax(NewScenePoint.y(), NodeRangeMin.y())));
return NewScenePoint;
}
if (!m_SuspendUpdate && Change == QGraphicsItem::ItemPositionHasChanged)
{
m_pTransferFunctionItem->m_AllowUpdateNodes = false;
m_pNode->SetIntensity(NewScenePoint.x() / m_pTransferFunctionItem->rect().width());
m_pNode->SetOpacity(1.0f - (NewScenePoint.y() / m_pTransferFunctionItem->rect().height()));
m_pTransferFunctionItem->m_AllowUpdateNodes = true;
return NewScenePoint;
}
return QGraphicsItem::itemChange(Change, Value);
}
void KItemListViewAnimation::start(QGraphicsWidget* widget, AnimationType type, const QVariant& endValue)
{
stop(widget, type);
QPropertyAnimation* propertyAnim = nullptr;
const int animationDuration = widget->style()->styleHint(QStyle::SH_Widget_Animate) ? 200 : 1;
switch (type) {
case MovingAnimation: {
const QPointF newPos = endValue.toPointF();
if (newPos == widget->pos()) {
return;
}
propertyAnim = new QPropertyAnimation(widget, "pos");
propertyAnim->setDuration(animationDuration);
propertyAnim->setEndValue(newPos);
break;
}
case CreateAnimation: {
propertyAnim = new QPropertyAnimation(widget, "opacity");
propertyAnim->setEasingCurve(QEasingCurve::InQuart);
propertyAnim->setDuration(animationDuration);
propertyAnim->setStartValue(0.0);
propertyAnim->setEndValue(1.0);
break;
}
case DeleteAnimation: {
propertyAnim = new QPropertyAnimation(widget, "opacity");
propertyAnim->setEasingCurve(QEasingCurve::OutQuart);
propertyAnim->setDuration(animationDuration);
propertyAnim->setStartValue(1.0);
propertyAnim->setEndValue(0.0);
break;
}
case ResizeAnimation: {
const QSizeF newSize = endValue.toSizeF();
if (newSize == widget->size()) {
return;
}
propertyAnim = new QPropertyAnimation(widget, "size");
propertyAnim->setDuration(animationDuration);
propertyAnim->setEndValue(newSize);
break;
}
default:
break;
}
Q_ASSERT(propertyAnim);
connect(propertyAnim, &QPropertyAnimation::finished, this, &KItemListViewAnimation::slotFinished);
m_animation[type].insert(widget, propertyAnim);
propertyAnim->start();
}
