How to know a QGraphicsItem is moving - qt

Question

I have a child class of QGraphicsItem with Selectable, Movable and SendsScenePositionChanges flags. When I select many items and moving them, all recieves itemChange event. Is there any way to detect in itemChanged if the item is moving? (or other way but in item level not scene level)
I tried to check if the left button was held down, but this way seems not working.
QVariant BaseItem::itemChange(GraphicsItemChange change, const QVariant &value)
{
if (change == ItemScenePositionHasChanged)
{
Qt::MouseButtons btns = QApplication::mouseButtons();
if (btns & Qt::LeftButton) {
// The left button is pressed.
mIsMoving = true;
}
else
{
mIsMoving = false; // this line is never triggered
}
}
return QGraphicsItem::itemChange(change, value);
}
Edit:
Let me describe my original needs, there are item1 and item2, an arrow connect between them, let's call it arrowItem, if I move item1, the arrow also needs to automatically adjust the shape to apply the new position, let's call this shape autoShape. User can also adjust the shape of the arrow, let's call it customShape.
Now, If item1 and item2 are selected at the same time and moved together, the arrow (has customShape) just need to move with them, no need to adjust the shape automatically . My current code flow is as follows: the movement of item1 triggers the update of the arrow, then the arrow needs to check whether item2 is also moving. If item2 is not moving, then automatically adjust the shape of the arrow. If item2 is also moving and the movement is same as item1, then Just move the arrowItem directly, no need to adjust the shape. Both item1 and item2 may be children of some other items.

Answer 1

Seems like you have to enable ItemSendsGeometryChanges flag to receive this event. Also, there are two similar but different events: QGraphicsItem::ItemPositionChange and QGraphicsItem::ItemPositionHasChanged. The first one is triggered when the item is moving, and the second one is after it finishes moving. The difference is that .pos() returns different values if called in the event callback. For the first event, it returns the original item position, and in the case of the second event, it returns a new position. Both events have new positions in their argument.
More about those events: https://doc.qt.io/qt-6/qgraphicsitem.html#GraphicsItemChange-enum
EDIT:
Based on the comments from the author of the question. After testing, it seems that QGraphicsItem::ItemPositionHasChanged and QGraphicsItem::ItemScenePositionHasChanged (which is useful to the author) are regularly and very often emitted after QGraphicsItem::ItemPositionChange.
In my case, when grabbing the item and shaking the mouse, the QGraphicsItem::ItemPositionChange was emitted exactly 2 times between each QGraphicsItem::ItemScenePositionHasChanged.
The only experimental difference I see between them is that in QGraphicsItem::ItemPositionChange callback, by calling .pos(), you can still access old item position, while in QGraphicsItem::ItemPositionHasChanged and QGraphicsItem::ItemScenePositionHasChanged calling .pos() results in a new item position.
So if for some reason the old item position is needed, then it is sufficient to additionally store it as a member of the derived class and update it in the QGraphicsItem::ItemScenePositionHasChanged callback when you're done.
EDIT 2:
With more information on the problem from the author. My approach would be to implement a "movement check" in the following way. If all of the selected items move together, then when item1 moves, it checks whether item2 is also currently selected (thereby, it also moves) with item1->scene()->selectedItems()->indexOf(item2).
If the result is -1, it means that item2 is not selected, hence, it is not moving and the arrow shape needs to be updated; otherwise, move the arrow along with both items.