In the scene editor, paste cut instances at highest z order (#4726)

AlexandreSi · web-flow · commit e10dd57fed40 · 2022-12-22T10:53:26.000+01:00
diff --git a/newIDE/app/src/InstancesEditor/InstancesAdder.js b/newIDE/app/src/InstancesEditor/InstancesAdder.js
@@ -1,5 +1,6 @@
 // @flow
 import { roundPosition } from '../Utils/GridHelpers';
+import { unserializeFromJSObject } from '../Utils/Serializer';
 import { type InstancesEditorSettings } from './InstancesEditorSettings';
 const gd: libGDevelop = global.gd;
 
@@ -51,6 +52,67 @@ export default class InstancesAdder {
     this._instancesEditorSettings = instancesEditorSettings;
   }
 
+  addSerializedInstances = ({
+    position,
+    copyReferential,
+    serializedInstances,
+    preventSnapToGrid = false,
+    addInstancesInTheForeground = false,
+  }: {|
+    position: [number, number],
+    copyReferential: [number, number],
+    serializedInstances: Array<Object>,
+    preventSnapToGrid?: boolean,
+    addInstancesInTheForeground?: boolean,
+  |}): Array<gdInitialInstance> => {
+    this._zOrderFinder.reset();
+    this._instances.iterateOverInstances(this._zOrderFinder);
+    const sceneForegroundZOrder = this._zOrderFinder.getHighestZOrder() + 1;
+
+    let addedInstancesLowestZOrder = null;
+
+    const newInstances = serializedInstances.map(serializedInstance => {
+      const instance = new gd.InitialInstance();
+      unserializeFromJSObject(instance, serializedInstance);
+      const desiredPosition = [
+        instance.getX() - copyReferential[0] + position[0],
+        instance.getY() - copyReferential[1] + position[1],
+      ];
+      const newPos = preventSnapToGrid
+        ? desiredPosition
+        : roundPositionsToGrid(desiredPosition, this._instancesEditorSettings);
+      instance.setX(newPos[0]);
+      instance.setY(newPos[1]);
+      if (addInstancesInTheForeground) {
+        if (
+          addedInstancesLowestZOrder === null ||
+          addedInstancesLowestZOrder > instance.getZOrder()
+        ) {
+          addedInstancesLowestZOrder = instance.getZOrder();
+        }
+      }
+      const newInstance = this._instances
+        .insertInitialInstance(instance)
+        .resetPersistentUuid();
+      instance.delete();
+      return newInstance;
+    });
+
+    if (addInstancesInTheForeground && addedInstancesLowestZOrder !== null) {
+      newInstances.forEach(instance => {
+        instance.setZOrder(
+          instance.getZOrder() -
+            // Flow is not happy with addedInstancesLowestZOrder possible null value
+            // so 0 is used as a fallback.
+            (addedInstancesLowestZOrder || 0) +
+            sceneForegroundZOrder
+        );
+      });
+    }
+
+    return newInstances;
+  };
+
   /**
    * Immediately create new instance at the specified position
    * (specified in scene coordinates).
diff --git a/newIDE/app/src/InstancesEditor/index.js b/newIDE/app/src/InstancesEditor/index.js
@@ -549,12 +549,26 @@ export default class InstancesEditor extends Component<Props> {
   };
 
   /**
-   * Immediately add instances for the specified objects at the given
+   * Immediately add serialized instances at the given
    * position (in scene coordinates).
    */
+  addSerializedInstances = (options: {|
+    position: [number, number],
+    copyReferential: [number, number],
+    serializedInstances: Array<Object>,
+    preventSnapToGrid?: boolean,
+    addInstancesInTheForeground?: boolean,
+  |}): Array<gdInitialInstance> => {
+    return this._instancesAdder.addSerializedInstances(options);
+  };
+
+  /**
+   * Immediately add instances for the specified objects at the given
+   * position (in scene coordinates) given their names.
+   */
   addInstances = (
-    pos /*: [number, number] */,
-    objectNames /*: Array<string> */
+    pos: [number, number],
+    objectNames: Array<string>
   ): Array<gdInitialInstance> => {
     return this._instancesAdder.addInstances(pos, objectNames);
   };
diff --git a/newIDE/app/src/ObjectsList/index.js b/newIDE/app/src/ObjectsList/index.js
@@ -316,28 +316,22 @@ const ObjectsList = React.forwardRef<Props, ObjectsListInterface>(
       [copyObject, deleteObject]
     );
 
-    const paste = React.useCallback(
-      (objectWithContext: ObjectWithContext): ?ObjectWithContext => {
-        if (!Clipboard.has(CLIPBOARD_KIND)) return null;
-
-        const { object: pasteObject, global } = objectWithContext;
-        const clipboardContent = Clipboard.get(CLIPBOARD_KIND);
-        const copiedObject = SafeExtractor.extractObjectProperty(
-          clipboardContent,
-          'object'
-        );
-        const name = SafeExtractor.extractStringProperty(
-          clipboardContent,
-          'name'
-        );
-        const type = SafeExtractor.extractStringProperty(
-          clipboardContent,
-          'type'
-        );
-        if (!name || !type || !copiedObject) return;
-
+    const addSerializedObjectToObjectsContainer = React.useCallback(
+      ({
+        objectName,
+        positionObjectName,
+        objectType,
+        global,
+        serializedObject,
+      }: {|
+        objectName: string,
+        positionObjectName: string,
+        objectType: string,
+        global: boolean,
+        serializedObject: Object,
+      |}): ObjectWithContext => {
         const newName = newNameGenerator(
-          name,
+          objectName,
           name =>
             objectsContainer.hasObjectNamed(name) ||
             project.hasObjectNamed(name),
@@ -347,31 +341,64 @@ const ObjectsList = React.forwardRef<Props, ObjectsListInterface>(
         const newObject = global
           ? project.insertNewObject(
               project,
-              type,
+              objectType,
               newName,
-              project.getObjectPosition(pasteObject.getName()) + 1
+              project.getObjectPosition(positionObjectName) + 1
             )
           : objectsContainer.insertNewObject(
               project,
-              type,
+              objectType,
               newName,
-              objectsContainer.getObjectPosition(pasteObject.getName()) + 1
+              objectsContainer.getObjectPosition(positionObjectName) + 1
             );
 
         unserializeFromJSObject(
           newObject,
-          copiedObject,
+          serializedObject,
           'unserializeFrom',
           project
         );
         newObject.setName(newName); // Unserialization has overwritten the name.
 
+        return { object: newObject, global };
+      },
+      [objectsContainer, project]
+    );
+
+    const paste = React.useCallback(
+      (objectWithContext: ObjectWithContext): ?ObjectWithContext => {
+        if (!Clipboard.has(CLIPBOARD_KIND)) return null;
+
+        const { object: pasteObject, global } = objectWithContext;
+        const clipboardContent = Clipboard.get(CLIPBOARD_KIND);
+        const copiedObject = SafeExtractor.extractObjectProperty(
+          clipboardContent,
+          'object'
+        );
+        const name = SafeExtractor.extractStringProperty(
+          clipboardContent,
+          'name'
+        );
+        const type = SafeExtractor.extractStringProperty(
+          clipboardContent,
+          'type'
+        );
+        if (!name || !type || !copiedObject) return;
+
+        const newObjectWithContext = addSerializedObjectToObjectsContainer({
+          objectName: name,
+          positionObjectName: pasteObject.getName(),
+          objectType: type,
+          serializedObject: copiedObject,
+          global,
+        });
+
         onObjectModified(false);
-        if (onObjectPasted) onObjectPasted(newObject);
+        if (onObjectPasted) onObjectPasted(newObjectWithContext.object);
 
-        return { object: newObject, global };
+        return newObjectWithContext;
       },
-      [objectsContainer, onObjectModified, onObjectPasted, project]
+      [addSerializedObjectToObjectsContainer, onObjectModified, onObjectPasted]
     );
 
     const editName = React.useCallback(
@@ -383,19 +410,25 @@ const ObjectsList = React.forwardRef<Props, ObjectsListInterface>(
       []
     );
 
-    const pasteAndRename = React.useCallback(
-      (objectWithContext: ObjectWithContext) => {
-        editName(paste(objectWithContext));
-      },
-      [editName, paste]
-    );
-
     const duplicateObject = React.useCallback(
       (objectWithContext: ObjectWithContext) => {
-        copyObject(objectWithContext);
-        pasteAndRename(objectWithContext);
+        const { object, global } = objectWithContext;
+
+        const type = object.getType();
+        const name = object.getName();
+        const serializedObject = serializeToJSObject(object);
+
+        const newObjectWithContext = addSerializedObjectToObjectsContainer({
+          objectName: name,
+          positionObjectName: name,
+          objectType: type,
+          serializedObject,
+          global,
+        });
+
+        editName(newObjectWithContext);
       },
-      [copyObject, pasteAndRename]
+      [addSerializedObjectToObjectsContainer, editName]
     );
 
     const rename = React.useCallback(
diff --git a/newIDE/app/src/SceneEditor/index.js b/newIDE/app/src/SceneEditor/index.js
@@ -24,10 +24,7 @@ import SetupGridDialog from './SetupGridDialog';
 import ScenePropertiesDialog from './ScenePropertiesDialog';
 import { type ObjectEditorTab } from '../ObjectEditor/ObjectEditorDialog';
 import Toolbar from './Toolbar';
-import {
-  serializeToJSObject,
-  unserializeFromJSObject,
-} from '../Utils/Serializer';
+import { serializeToJSObject } from '../Utils/Serializer';
 import Clipboard, { SafeExtractor } from '../Utils/Clipboard';
 import Window from '../Utils/Window';
 import FullSizeInstancesEditorWithScrollbars from '../InstancesEditor/FullSizeInstancesEditorWithScrollbars';
@@ -157,7 +154,10 @@ type State = {|
   selectedObjectTags: SelectedTags,
 |};
 
-type CopyCutPasteOptions = { useLastCursorPosition?: boolean };
+type CopyCutPasteOptions = {|
+  useLastCursorPosition?: boolean,
+  pasteInTheForeground?: boolean,
+|};
 
 export default class SceneEditor extends React.Component<Props, State> {
   static defaultProps = {
@@ -1126,7 +1126,10 @@ export default class SceneEditor extends React.Component<Props, State> {
     return contextMenuItems;
   };
 
-  copySelection = ({ useLastCursorPosition }: CopyCutPasteOptions = {}) => {
+  copySelection = ({
+    useLastCursorPosition,
+    pasteInTheForeground,
+  }: CopyCutPasteOptions = {}) => {
     const serializedSelection = this.instancesSelection
       .getSelectedInstances()
       .map(instance => serializeToJSObject(instance));
@@ -1138,33 +1141,29 @@ export default class SceneEditor extends React.Component<Props, State> {
       Clipboard.set(INSTANCES_CLIPBOARD_KIND, {
         x: position[0],
         y: position[1],
+        pasteInTheForeground: !!pasteInTheForeground,
         instances: serializedSelection,
       });
     }
   };
 
-  cutSelection = (options: CopyCutPasteOptions = {}) => {
-    this.copySelection(options);
+  cutSelection = ({ useLastCursorPosition }: CopyCutPasteOptions = {}) => {
+    this.copySelection({ useLastCursorPosition, pasteInTheForeground: true });
     this.deleteSelection();
   };
 
   duplicateSelection = () => {
+    const { editor } = this;
+    if (!editor) return;
     const serializedSelection = this.instancesSelection
       .getSelectedInstances()
       .map(instance => serializeToJSObject(instance));
 
-    if (!this.editor) return;
-
-    const newInstances = serializedSelection.map(serializedInstance => {
-      const instance = new gd.InitialInstance();
-      unserializeFromJSObject(instance, serializedInstance);
-      instance.setX(instance.getX() + 2 * MOVEMENT_BIG_DELTA);
-      instance.setY(instance.getY() + 2 * MOVEMENT_BIG_DELTA);
-      const newInstance = this.props.initialInstances
-        .insertInitialInstance(instance)
-        .resetPersistentUuid();
-      instance.delete();
-      return newInstance;
+    const newInstances = editor.addSerializedInstances({
+      position: [0, 0],
+      copyReferential: [-2 * MOVEMENT_BIG_DELTA, -2 * MOVEMENT_BIG_DELTA],
+      serializedInstances: serializedSelection,
+      preventSnapToGrid: true,
     });
     this._onInstancesAdded(newInstances);
     this.instancesSelection.clearSelection();
@@ -1176,11 +1175,12 @@ export default class SceneEditor extends React.Component<Props, State> {
   };
 
   paste = ({ useLastCursorPosition }: CopyCutPasteOptions = {}) => {
-    if (!this.editor) return;
+    const { editor } = this;
+    if (!editor) return;
 
     const position = useLastCursorPosition
-      ? this.editor.getLastCursorSceneCoordinates()
-      : this.editor.getLastContextMenuSceneCoordinates();
+      ? editor.getLastCursorSceneCoordinates()
+      : editor.getLastContextMenuSceneCoordinates();
 
     const clipboardContent = Clipboard.get(INSTANCES_CLIPBOARD_KIND);
     const instancesContent = SafeExtractor.extractArrayProperty(
@@ -1189,19 +1189,20 @@ export default class SceneEditor extends React.Component<Props, State> {
     );
     const x = SafeExtractor.extractNumberProperty(clipboardContent, 'x');
     const y = SafeExtractor.extractNumberProperty(clipboardContent, 'y');
+    const pasteInTheForeground =
+      SafeExtractor.extractBooleanProperty(
+        clipboardContent,
+        'pasteInTheForeground'
+      ) || false;
     if (x === null || y === null || instancesContent === null) return;
 
-    const newInstances = instancesContent.map(serializedInstance => {
-      const instance = new gd.InitialInstance();
-      unserializeFromJSObject(instance, serializedInstance);
-      instance.setX(instance.getX() - x + position[0]);
-      instance.setY(instance.getY() - y + position[1]);
-      const newInstance = this.props.initialInstances
-        .insertInitialInstance(instance)
-        .resetPersistentUuid();
-      instance.delete();
-      return newInstance;
+    const newInstances = editor.addSerializedInstances({
+      position,
+      copyReferential: [x, y],
+      serializedInstances: instancesContent,
+      addInstancesInTheForeground: pasteInTheForeground,
     });
+
     this._onInstancesAdded(newInstances);
     this.instancesSelection.clearSelection();
     this.instancesSelection.selectInstances({
