LY-91616 Dyn Veg: Push (up) and Pop (down) Items in Descriptor List (#3013)

* LY-91616 Dyn Veg: Push (up) and Pop (down) Items in Descriptor List Signed-off-by: sphrose <82213493+sphrose@users.noreply.github.com> * Changes as per reviews. Signed-off-by: sphrose <82213493+sphrose@users.noreply.github.com> * Additional review changes. Signed-off-by: sphrose <82213493+sphrose@users.noreply.github.com> * review change Signed-off-by: sphrose <82213493+sphrose@users.noreply.github.com>
2021-08-16 10:54:15 +01:00
parent 83f6cb813a
commit 181698b950
7 changed files with 1441 additions and 189 deletions
@@ -1882,7 +1882,10 @@ namespace AzQtComponents
            return;
        }

-        QApplication::setOverrideCursor(m_dragCursor);
+        if (!QApplication::overrideCursor())
+        {
+            QApplication::setOverrideCursor(m_dragCursor);
+        }

        QPoint relativePressPos = pressPos;

@@ -19,6 +19,7 @@
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/ComponentBus.h>
 #include <AzCore/Component/EntityBus.h>
+#include <AzCore/Component/TickBus.h>
 #include <AzCore/Asset/AssetCommon.h>
 #include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h>
 #include <AzToolsFramework/Undo/UndoSystem.h>
@@ -110,6 +111,7 @@ namespace AzToolsFramework
        , public EditorInspectorComponentNotificationBus::MultiHandler
        , private AzToolsFramework::ComponentModeFramework::EditorComponentModeNotificationBus::Handler
        , public AZ::EntitySystemBus::Handler
+        , public AZ::TickBus::Handler
        , private EditorWindowUIRequestBus::Handler
    {
        Q_OBJECT;
@@ -117,6 +119,23 @@ namespace AzToolsFramework

        AZ_CLASS_ALLOCATOR(EntityPropertyEditor, AZ::SystemAllocator, 0)

+        enum class ReorderState
+        {
+            Inactive, // No row widget reordering operation is in progress.
+            DraggingComponent, // User is dragging a component editor.
+            DraggingRowWidget, // User is dragging a row widget around.
+            UsingMenu, // User has the context menu open and may hover over a move up/down operation.
+            MenuOperationInProgress, // User has selected a move/up down menu item.
+            WaitForRedraw, // Wait for rebuild of RPE.
+            HighlightMovedRow // User has moved a row, highlight the new position.
+        };
+
+        enum class DropArea
+        {
+            Above,
+            Below
+        };
+
        EntityPropertyEditor(QWidget* pParent = NULL, Qt::WindowFlags flags = Qt::WindowFlags(), bool isLevelEntityEditor = false);
        virtual ~EntityPropertyEditor();

@@ -151,6 +170,16 @@ namespace AzToolsFramework
        bool IsLockedToSpecificEntities() const { return !m_overrideSelectedEntityIds.empty(); }

        static bool AreComponentsCopyable(const AZ::Entity::ComponentArrayType& components, const ComponentFilter& filter);
+
+        ReorderState GetReorderState() const;
+        ComponentEditor* GetEditorForCurrentReorderRowWidget() const;
+        PropertyRowWidget* GetReorderRowWidget() const;
+        PropertyRowWidget* GetReorderDropTarget() const;
+        DropArea GetReorderDropArea() const;
+        QPixmap GetReorderRowWidgetImage() const;
+        float GetMoveIndicatorAlpha() const;
+        PropertyRowWidget* GetRowToHighlight();
+
    Q_SIGNALS:
        void SelectedEntityNameChanged(const AZ::EntityId& entityId, const AZStd::string& name);

@@ -211,6 +240,9 @@ namespace AzToolsFramework
        void GetSelectedEntities(EntityIdList& selectedEntityIds) override;
        void SetNewComponentId(AZ::ComponentId componentId) override;

+        // TickBus
+        void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+
        // EditorWindowRequestBus overrides
        void SetEditorUiEnabled(bool enable) override;

@@ -253,6 +285,10 @@ namespace AzToolsFramework
        void ContextMenuActionPullFieldData(AZ::Component* parentComponent, InstanceDataNode* fieldNode);
        void ContextMenuActionSetDataFlag(InstanceDataNode* node, AZ::DataPatch::Flag flag, bool additive);

+        void GenerateRowWidgetIndexMapToChildIndex(PropertyRowWidget* parent, int destIndex);
+        void ContextMenuActionMoveItemUp(ComponentEditor* componentEditor, PropertyRowWidget* rowWidget);
+        void ContextMenuActionMoveItemDown(ComponentEditor* componentEditor, PropertyRowWidget* rowWidget);
+
        /// Given an InstanceDataNode, calculate a DataPatch address relative to the entity.
        /// @return true if successful.
        bool GetEntityDataPatchAddress(const InstanceDataNode* componentFieldNode, AZ::DataPatch::AddressType& dataPatchAddressOut, AZ::EntityId* entityIdOut = nullptr) const;
@@ -341,8 +377,6 @@ namespace AzToolsFramework
        QAction* m_actionToMoveComponentsBottom = nullptr;
        QAction* m_resetToSliceAction = nullptr;

-        bool m_isShowingContextMenu = false;
-
        void CreateActions();
        void UpdateActions();

@@ -390,6 +424,10 @@ namespace AzToolsFramework
        void ResetToSlice();

        bool DoesOwnFocus() const;
+        AZ::u32 GetHeightOfRowAndVisibleChildren(const PropertyRowWidget* row) const;
+        QRect GetWidgetAndVisibleChildrenGlobalRect(const PropertyRowWidget* widget) const;
+        PropertyRowWidget* GetRowWidgetAtSameLevelAfter(PropertyRowWidget* widget) const;
+        PropertyRowWidget* GetRowWidgetAtSameLevelBefore(PropertyRowWidget* widget) const;
        QRect GetWidgetGlobalRect(const QWidget* widget) const;
        bool DoesIntersectWidget(const QRect& globalRect, const QWidget* widget) const;
        bool DoesIntersectSelectedComponentEditor(const QRect& globalRect) const;
@@ -445,6 +483,8 @@ namespace AzToolsFramework
        bool HandleSelectionEvents(QObject* object, QEvent* event);
        bool m_selectionEventAccepted;

+        bool HandleMenuEvent(QObject* object, QEvent* event);
+
        // drag and drop events
        QRect GetInflatedRectFromPoint(const QPoint& point, int radius) const;
        bool GetComponentsAtDropEventPosition(QDropEvent* event, AZ::Entity::ComponentArrayType& targetComponents);
@@ -458,8 +498,12 @@ namespace AzToolsFramework

        ComponentEditor* GetReorderDropTarget(const QRect& globalRect) const;
        bool ResetDrag(QMouseEvent* event);
+        bool FindAllowedRowWidgetReorderDropTarget(const QPoint& globalPos);
+        bool UpdateRowWidgetDrag(const QPoint& localPos, Qt::MouseButtons mouseButtons, const QMimeData* mimeData);
+        PropertyRowWidget* FindPropertyRowWidgetAt(QPoint globalPos);
        bool UpdateDrag(const QPoint& localPos, Qt::MouseButtons mouseButtons, const QMimeData* mimeData);
        bool StartDrag(QMouseEvent* event);
+        void EndRowWidgetReorder();
        bool HandleDrop(QDropEvent* event);
        bool HandleDropForComponentTypes(QDropEvent* event);
        bool HandleDropForComponentAssets(QDropEvent* event);
@@ -468,6 +512,8 @@ namespace AzToolsFramework
        bool CanDropForComponentTypes(const QMimeData* mimeData) const;
        bool CanDropForComponentAssets(const QMimeData* mimeData) const;
        bool CanDropForAssetBrowserEntries(const QMimeData* mimeData) const;
+        void SetRowWidgetHighlighted(PropertyRowWidget* rowWidget);
+
        AZStd::vector<AZ::s32> ExtractComponentEditorIndicesFromMimeData(const QMimeData* mimeData) const;
        ComponentEditorVector GetComponentEditorsFromIndices(const AZStd::vector<AZ::s32>& indices) const;
        ComponentEditor* GetComponentEditorsFromIndex(const AZ::s32 index) const;
@@ -559,6 +605,8 @@ namespace AzToolsFramework

        QIcon m_emptyIcon;
        QIcon m_clearIcon;
+        QIcon m_dragIcon;
+        QCursor m_dragCursor;

        QStandardItem* m_comboItems[StatusItems];
        EntityIdSet m_overrideSelectedEntityIds;
@@ -566,6 +614,19 @@ namespace AzToolsFramework
        Prefab::PrefabPublicInterface* m_prefabPublicInterface = nullptr;
        bool m_prefabsAreEnabled = false;

+        // Reordering row widgets within the RPE.
+        static constexpr float MoveFadeSeconds = 0.5f;
+
+        ReorderState m_currentReorderState = ReorderState::Inactive;
+        ComponentEditor* m_reorderRowWidgetEditor = nullptr;
+        InstanceDataNode* m_nodeToMove = nullptr;
+        PropertyRowWidget* m_reorderRowWidget = nullptr;
+        PropertyRowWidget* m_reorderDropTarget = nullptr;
+        DropArea m_reorderDropArea = DropArea::Above;
+        QPixmap m_reorderRowImage;
+        float m_moveFadeSecondsRemaining;
+        AZStd::vector<int> m_indexMapOfMovedRow;
+
        // When m_initiatingPropertyChangeNotification is set to true, it means this EntityPropertyEditor is
        // broadcasting a change to all listeners about a property change for a given entity.  This is needed
        // so that we don't update the values twice for this inspector
@@ -573,6 +634,9 @@ namespace AzToolsFramework
        void ConnectToEntityBuses(const AZ::EntityId& entityId);
        void DisconnectFromEntityBuses(const AZ::EntityId& entityId);

+        void BeginMoveRowWidgetFade();
+        void HighlightMovedRowWidget();
+
        //! Stores a component id to be focused on next time the UI updates.
        AZStd::optional<AZ::ComponentId> m_newComponentId;

@@ -594,6 +658,8 @@ namespace AzToolsFramework

        bool SelectedEntitiesAreFromSameSourceSliceEntity() const;

+        void DragStopped();
+
        AZ::Entity* GetSelectedEntityById(AZ::EntityId& entityId) const;
    };

@@ -368,10 +368,15 @@ namespace AzToolsFramework
            delete m_containerAddButton;
        }

+        this->unsetCursor();
+
        if ((m_parentRow) && (m_parentRow->IsContainerEditable()))
        {
            if (!m_elementRemoveButton)
            {
+                QIcon icon = QIcon(QStringLiteral(":/Cursors/Grab_release.svg"));
+                this->setCursor(QCursor(icon.pixmap(16), 5, 2));
+
                static QIcon s_iconRemove(QStringLiteral(":/stylesheet/img/UI20/delete-16.svg"));
                m_elementRemoveButton = new QToolButton(this);
                m_elementRemoveButton->setAutoRaise(true);
@@ -570,7 +575,12 @@ namespace AzToolsFramework
        AZ_Assert(m_selectionEnabled, "Property is not selectable");
        m_isSelected = selected;
        m_nameLabel->setProperty("selected", selected);
-    }    
+    }
+
+    bool PropertyRowWidget::GetSelected()
+    {
+        return m_isSelected;
+    }   
    
    void PropertyRowWidget::SetSelectionEnabled(bool selectionEnabled)
    {
@@ -1395,6 +1405,21 @@ namespace AzToolsFramework
        return !m_childrenRows.empty(); 
    }

+    AZ::u32 PropertyRowWidget::GetChildRowCount() const
+    {
+        return static_cast<AZ::u32>(m_childrenRows.size());
+    }
+
+    PropertyRowWidget* PropertyRowWidget::GetChildRowByIndex(AZ::u32 index) const
+    {
+        if (index >= m_childrenRows.size())
+        {
+            return nullptr;
+        }
+
+        return m_childrenRows[index];
+    }
+
    bool PropertyRowWidget::ShouldPreValidatePropertyChange() const
    {
        return (m_changeValidators.size() > 0);
@@ -1722,6 +1747,162 @@ namespace AzToolsFramework

        return m_parentRow->CanChildrenBeReordered();
    }
+
+        int PropertyRowWidget::GetIndexInParent() const
+    {
+        if (!GetParentRow())
+        {
+            return -1;
+        }
+
+        for (int index = 0; index < GetParentRow()->GetChildRowCount(); index++)
+        {
+            if (GetParentRow()->GetChildrenRows()[index] == this)
+            {
+                return index;
+            }
+        }
+
+        return -1;
+    }
+
+    bool PropertyRowWidget::CanMoveUp() const
+    {
+        if (!CanBeReordered())
+        {
+            return false;
+        }
+
+        return this != m_parentRow->GetChildRowByIndex(0);
+    }
+
+    bool PropertyRowWidget::CanMoveDown() const
+    {
+        if (!CanBeReordered())
+        {
+            return false;
+        }
+
+        AZ::u32 numChildrenOfParent = m_parentRow->GetChildRowCount();
+
+        return this != m_parentRow->GetChildRowByIndex(numChildrenOfParent - 1);
+    }
+
+    int PropertyRowWidget::GetContainingEditorFrameWidth()
+    {
+        QWidget* parent = parentWidget();
+
+        // Find the first ancestor that can be cast to a QFrame, this will be the RPE.
+        while (!qobject_cast<QFrame*>(parent))
+        {
+            parent = parent->parentWidget();
+        }
+
+        if (!parent)
+        {
+            return 0;
+        }
+
+        // The parent of the RPE is the size we want.
+        parent = parent->parentWidget();
+        
+        return parent->rect().width();
+    }
+
+    int PropertyRowWidget::GetHeightOfRowAndVisibleChildren()
+    {
+        int height = rect().height();
+
+        if (!GetChildRowCount() || !IsExpanded())
+        {
+            return height;
+        }
+
+        for (auto childRow : GetChildrenRows())
+        {
+            height += childRow->GetHeightOfRowAndVisibleChildren();
+        }
+
+        return height;
+    }
+
+    int PropertyRowWidget::DrawDragImageAndVisibleChildrenInto(QPainter& painter, int xpos, int ypos)
+    {
+        // Render our image into the given painter.
+        int ystart = ypos;
+
+        render(&painter, QPoint(xpos, ypos));
+
+        if (!GetChildRowCount() || !IsExpanded())
+        {
+            return rect().height();
+        }
+
+        ypos += rect().height();
+
+        // Recursively draw any children.
+        for (auto childRow : GetChildrenRows())
+        {
+            ypos += childRow->DrawDragImageAndVisibleChildrenInto(painter, xpos, ypos);
+        }
+
+        return ypos - ystart;
+    }
+
+    QPixmap PropertyRowWidget::createDragImage(
+        const QColor backgroundColor, const QColor borderColor, const float alpha, DragImageType imageType)
+    {
+        // Make the drag box as wide as the containing editor minus a gap each side for the border.
+        static constexpr int ParentEditorBorderSize = 2;
+        int width = GetContainingEditorFrameWidth() - ParentEditorBorderSize * 2;
+        int height = 0;
+
+        if (imageType == DragImageType::IncludeVisibleChildren)
+        {
+            height = GetHeightOfRowAndVisibleChildren();
+        }
+        else
+        {
+            height = rect().height();
+        }
+
+        const auto dpr = devicePixelRatioF();
+        QPixmap dragImage(width * dpr, height * dpr);
+        dragImage.setDevicePixelRatio(dpr);
+        dragImage.fill(Qt::transparent);
+
+        QRect imageRect = QRect(0, 0, width, height);
+
+        QPainter dragPainter(&dragImage);
+        dragPainter.setCompositionMode(QPainter::CompositionMode_Source);
+        dragPainter.fillRect(imageRect, Qt::transparent);
+        dragPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+        dragPainter.setOpacity(alpha);
+        dragPainter.fillRect(imageRect, backgroundColor);
+
+        dragPainter.setOpacity(1.0f);
+
+        int marginWidth = (imageRect.width() - rect().width()) / 2 + ParentEditorBorderSize - 1;
+
+        if (imageType == DragImageType::IncludeVisibleChildren)
+        {
+            DrawDragImageAndVisibleChildrenInto(dragPainter, marginWidth, 0);
+        }
+        else
+        {
+            render(&dragPainter, QPoint(marginWidth, 0));
+        }
+
+        QPen pen;
+        pen.setColor(QColor(borderColor));
+        pen.setWidth(1);
+        dragPainter.setPen(pen);
+        dragPainter.drawRect(0, 0, imageRect.width() - 1, imageRect.height() - 1);
+
+        dragPainter.end();
+
+        return dragImage;
+    }
 }

 #include "UI/PropertyEditor/moc_PropertyRowWidget.cpp"
@@ -45,6 +45,13 @@ namespace AzToolsFramework
        Q_PROPERTY(bool appendDefaultLabelToName READ GetAppendDefaultLabelToName WRITE AppendDefaultLabelToName)
    public:
        AZ_CLASS_ALLOCATOR(PropertyRowWidget, AZ::SystemAllocator, 0)
+
+        enum class DragImageType
+        {
+            SingleRow,
+            IncludeVisibleChildren
+        };
+
        PropertyRowWidget(QWidget* pParent);
        virtual ~PropertyRowWidget();

@@ -86,6 +93,9 @@ namespace AzToolsFramework
        bool GetAppendDefaultLabelToName();
        void AppendDefaultLabelToName(bool doAppend);

+        AZ::u32 GetChildRowCount() const;
+        PropertyRowWidget* GetChildRowByIndex(AZ::u32 index) const;
+
        AZStd::vector<PropertyRowWidget*>& GetChildrenRows() { return m_childrenRows; }
        bool HasChildRows() const;

@@ -124,6 +134,7 @@ namespace AzToolsFramework

        void SetSelectionEnabled(bool selectionEnabled);
        void SetSelected(bool selected);
+        bool GetSelected();
        bool eventFilter(QObject *watched, QEvent *event) override;
        void paintEvent(QPaintEvent*) override;

@@ -152,9 +163,18 @@ namespace AzToolsFramework
        bool CanChildrenBeReordered() const;
        bool CanBeReordered() const;

+        int GetIndexInParent() const;
+        bool CanMoveUp() const;
+        bool CanMoveDown() const;
+
+        int GetContainingEditorFrameWidth();
+        QPixmap createDragImage(const QColor backgroundColor, const QColor borderColor, const float alpha, DragImageType imageType);
    protected:
        int CalculateLabelWidth() const;

+        int GetHeightOfRowAndVisibleChildren();
+        int DrawDragImageAndVisibleChildrenInto(QPainter& painter, int xpos, int ypos);
+
        bool IsHidden(InstanceDataNode* node) const;

        struct ChangeNotification;
@@ -216,6 +236,7 @@ namespace AzToolsFramework
        bool m_isMultiSizeContainer = false;
        bool m_isFixedSizeOrSmartPtrContainer = false;
        bool m_custom = false;
+        bool m_canChildrenBeReordered = false;

        bool m_isSelected = false;
        bool m_selectionEnabled = false;
@@ -19,6 +19,7 @@
 #include <QtWidgets/QVBoxLayout>
 #include <QtWidgets/QScrollArea>
 #include <QtWidgets/QApplication>
+#include <QPainter>
 AZ_PUSH_DISABLE_WARNING(4251, "-Wunknown-warning-option") // 'QTextFormat::d': class 'QSharedDataPointer<QTextFormatPrivate>' needs to have dll-interface to be used by clients of class 'QTextFormat'
 #include <QtWidgets/QInputDialog>
 AZ_POP_DISABLE_WARNING
@@ -1343,7 +1344,7 @@ namespace AzToolsFramework

    // calculate the index/offset of the instance data node in the container
    // (useful for notifying which element in a vector was modified/removed)
-    static size_t CalculateElementIndexInContainer(
+    static int CalculateElementIndexInContainer(
        InstanceDataNode* node, void* parentInstanceNode,
        AZ::SerializeContext::IDataContainer* container, AZStd::vector<void*>& nodeInstancesOut)
    {
@@ -1358,7 +1359,7 @@ namespace AzToolsFramework
            }
        }

-        size_t elementIndex = 0;
+        int elementIndex = 0;
        void* elementPtr = nodeInstancesOut.empty() ? nullptr : nodeInstancesOut.front();

        // find the index of the element we are about to remove
@@ -1429,7 +1430,7 @@ namespace AzToolsFramework

                // if the element being modified exists in a container, calculate
                // the index to be passed through to PropertyNotify
-                const auto calculateElementIndex = [](InstanceDataNode* node) -> size_t {
+                const auto calculateElementIndex = [](InstanceDataNode* node) -> int {
                    if (InstanceDataNode* parent = node->GetParent())
                    {
                        if (AZ::SerializeContext::IDataContainer* container = parent->GetClassMetadata()->m_container)
@@ -1656,6 +1657,221 @@ namespace AzToolsFramework
            AzToolsFramework::Refresh_EntireTree);
    }

+    InstanceDataNode* ReflectedPropertyEditor::FindContainerNodeForNode(InstanceDataNode* node) const
+    {
+        // Locate the owning container. There may be a level of indirection due to wrappers, such as DynamicSerializableField.
+        InstanceDataNode* pContainerNode = node->GetParent();
+        if (!pContainerNode)
+        {
+            return nullptr;
+        }
+
+        while (pContainerNode && !pContainerNode->GetClassMetadata()->m_container)
+        {
+            pContainerNode = pContainerNode->GetParent();
+            node = node->GetParent();
+        }
+
+        // Check for pContainerNode again, can happen if a node is deleted during operation.
+        if (!pContainerNode)
+        {
+            return nullptr;
+        }
+
+        if (IsParentAssociativeContainer(pContainerNode) && IsPairContainer(pContainerNode))
+        {
+            // Go up one more level to the associative container, we'll remove the pair from that container
+            pContainerNode = pContainerNode->GetParent();
+            node = node->GetParent();
+        }
+
+        AZ_Assert(
+            pContainerNode, "Failed to locate parent container for element \"%s\" of type %s.",
+            node->GetElementMetadata() ? node->GetElementMetadata()->m_name : node->GetClassMetadata()->m_name,
+            node->GetClassMetadata()->m_typeId.ToString<AZStd::string>().c_str());
+
+        return pContainerNode;
+    }
+
+    InstanceDataNode* ReflectedPropertyEditor::GetNodeAtIndex(int index)
+    {
+        if (index >= m_impl->m_widgetsInDisplayOrder.size())
+        {
+            return nullptr;
+        }
+
+        return GetNodeFromWidget(m_impl->m_widgetsInDisplayOrder[index]);
+    }
+
+    QSet<PropertyRowWidget*> ReflectedPropertyEditor::GetTopLevelWidgets()
+    {
+        return m_impl->getTopLevelWidgets();
+    }
+
+    void ReflectedPropertyEditor::ChangeNodeIndex(InstanceDataNode* containerNode, InstanceDataNode* node, int fromIndex, int toIndex)
+    {
+        auto container = containerNode->GetElementMetadata()
+            ? containerNode->GetElementMetadata()->m_genericClassInfo->GetClassData()->m_container
+            : nullptr;
+
+        if (fromIndex == toIndex)
+        {
+            return;
+        }
+
+        if (!container || container->GetAssociativeContainerInterface())
+        {
+            return;
+        }
+
+        AZ::Uuid typeId = node->GetClassMetadata()->m_typeId;
+
+        if (m_impl->m_ptrNotify)
+        {
+            m_impl->m_ptrNotify->BeforePropertyModified(containerNode);
+        }
+
+        const AZ::SerializeContext::ClassElement* containerClassElement = container->GetElement(container->GetDefaultElementNameCrc());
+
+        AZ::SerializeContext* serializeContext = nullptr;
+        AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
+
+        // Backup the item we're moving.
+        void* srcElement = nullptr;
+        void* destElement = nullptr;
+
+        int destIndex = -1;
+        int srcIndex = fromIndex;
+
+        srcElement = container->GetElementByIndex(containerNode->GetInstance(0), containerClassElement, srcIndex);
+
+        void* tmpBuffer = serializeContext->CloneObject(srcElement, typeId);
+
+        // Shuffle all intervening items up (or down).
+        int indexOffset = (toIndex < fromIndex) ? -1 : 1;
+
+        while (destIndex != toIndex - indexOffset)
+        {
+            destIndex = srcIndex;
+            srcIndex += indexOffset;
+
+            destElement = srcElement;
+
+            srcElement = container->GetElementByIndex(containerNode->GetInstance(0), containerClassElement, srcIndex);
+
+            serializeContext->CloneObjectInplace(destElement, srcElement, typeId);
+        }
+
+        // Now replace the final element with the one backed up previously.
+        destElement = srcElement;
+
+        serializeContext->CloneObjectInplace(destElement, tmpBuffer, typeId);
+
+        if (m_impl->m_ptrNotify)
+        {
+            m_impl->m_ptrNotify->AfterPropertyModified(containerNode);
+            m_impl->m_ptrNotify->SealUndoStack();
+        }
+
+        // Need to refresh any pinned inspectors as well to keep the container state in sync
+        QueueInvalidation(Refresh_Values);
+        AzToolsFramework::ToolsApplicationEvents::Bus::Broadcast(
+            &AzToolsFramework::ToolsApplicationEvents::InvalidatePropertyDisplay, AzToolsFramework::Refresh_Values);
+    }
+
+    void ReflectedPropertyEditor::MoveNodeToIndex(InstanceDataNode* node, int index)
+    {
+        InstanceDataNode* pContainerNode = FindContainerNodeForNode(node);
+
+        if (!pContainerNode)
+        {
+            return;
+        }
+
+        AZ::SerializeContext::IDataContainer* container = pContainerNode->GetClassMetadata()->m_container;
+
+        AZStd::vector<void*> nodeInstancesOut;
+        const int elementIndex = CalculateElementIndexInContainer(node, pContainerNode->GetInstance(0), container, nodeInstancesOut);
+
+        ChangeNodeIndex(pContainerNode, node, elementIndex, index);
+    }
+
+    void ReflectedPropertyEditor::MoveNodeBefore(InstanceDataNode* nodeToMove, InstanceDataNode* nodeToMoveBefore)
+    {
+        InstanceDataNode* pContainerNode = FindContainerNodeForNode(nodeToMove);
+        InstanceDataNode* pContainerNodeTarget = FindContainerNodeForNode(nodeToMoveBefore);
+
+        if (nodeToMove == nodeToMoveBefore)
+        {
+            return;
+        }
+
+        // Can only move nodes within the same parent.
+        if (pContainerNode != pContainerNodeTarget)
+        {
+            return;
+        }
+
+        AZ::SerializeContext::IDataContainer* container = pContainerNode->GetClassMetadata()->m_container;
+
+        AZStd::vector<void*> nodeInstancesOut;
+        int elementIndex = CalculateElementIndexInContainer(nodeToMove, pContainerNode->GetInstance(0), container, nodeInstancesOut);
+        nodeInstancesOut.clear();
+        int elementIndexTarget =
+            CalculateElementIndexInContainer(nodeToMoveBefore, pContainerNode->GetInstance(0), container, nodeInstancesOut);
+
+        if (elementIndex < elementIndexTarget)
+        {
+            elementIndexTarget -= 1;
+        }
+
+        ChangeNodeIndex(pContainerNode, nodeToMove, elementIndex, elementIndexTarget);
+    }
+
+    void ReflectedPropertyEditor::MoveNodeAfter(InstanceDataNode* nodeToMove, InstanceDataNode* nodeToMoveBefore)
+    {
+        InstanceDataNode* pContainerNode = FindContainerNodeForNode(nodeToMove);
+        InstanceDataNode* pContainerNodeTarget = FindContainerNodeForNode(nodeToMoveBefore);
+
+        if (nodeToMove == nodeToMoveBefore)
+        {
+            return;
+        }
+
+        // Can only move nodes within the same parent.
+        if (pContainerNode != pContainerNodeTarget)
+        {
+            return;
+        }
+
+        AZ::SerializeContext::IDataContainer* container = pContainerNode->GetClassMetadata()->m_container;
+
+        AZStd::vector<void*> nodeInstancesOut;
+        int elementIndex = CalculateElementIndexInContainer(nodeToMove, pContainerNode->GetInstance(0), container, nodeInstancesOut);
+        nodeInstancesOut.clear();
+        int elementIndexTarget =
+            CalculateElementIndexInContainer(nodeToMoveBefore, pContainerNode->GetInstance(0), container, nodeInstancesOut);
+
+        if (elementIndex > elementIndexTarget)
+        {
+            elementIndexTarget += 1;
+        }
+
+        ChangeNodeIndex(pContainerNode, nodeToMove, elementIndex, elementIndexTarget);
+    }
+
+    int ReflectedPropertyEditor::GetNodeIndexInContainer(InstanceDataNode* node)
+    {
+        InstanceDataNode* pContainerNode = FindContainerNodeForNode(node);
+
+        AZ::SerializeContext::IDataContainer* container = pContainerNode->GetClassMetadata()->m_container;
+
+        AZStd::vector<void*> nodeInstancesOut;
+        int elementIndex = CalculateElementIndexInContainer(node, pContainerNode->GetInstance(0), container, nodeInstancesOut);
+
+        return elementIndex;
+    }
+
    void ReflectedPropertyEditor::OnPropertyRowRequestContainerRemoveItem(PropertyRowWidget* widget, InstanceDataNode* node)
    {
        // Locate the owning container. There may be a level of indirection due to wrappers, such as DynamicSerializableField.
@@ -1690,7 +1906,7 @@ namespace AzToolsFramework

        // the index of the element being removed
        AZStd::vector<void*> nodeInstancesOut;
-        const size_t elementIndex = CalculateElementIndexInContainer(
+        const int elementIndex = CalculateElementIndexInContainer(
            node, pContainerNode->GetInstance(0), container, nodeInstancesOut);

        // pass the context as the last parameter to actually delete the related data.
@@ -155,9 +155,19 @@ namespace AzToolsFramework
        using VisibilityCallback = AZStd::function<void(InstanceDataNode* node, NodeDisplayVisibility& visibility, bool& checkChildVisibility)>;
        void SetVisibilityCallback(VisibilityCallback callback);

+        void MoveNodeToIndex(InstanceDataNode* node, int index);
+        void MoveNodeBefore(InstanceDataNode* nodeToMove, InstanceDataNode* nodeToMoveBefore);
+        void MoveNodeAfter(InstanceDataNode* nodeToMove, InstanceDataNode* nodeToMoveBefore);
+
+        int GetNodeIndexInContainer(InstanceDataNode* node);
+        InstanceDataNode* GetNodeAtIndex(int index);
+        QSet<PropertyRowWidget*> GetTopLevelWidgets();
    signals:
        void OnExpansionContractionDone();
    private:
+        InstanceDataNode* FindContainerNodeForNode(InstanceDataNode* node) const;
+        void ChangeNodeIndex(InstanceDataNode* containerNode, InstanceDataNode* node, int oldIndex, int newIndex);
+
        class Impl;
        std::unique_ptr<Impl> m_impl;