Rename variables in variants.

Author: D8H

Core/GDCore/IDE/GroupVariableHelper.cpp

@@ -12,6 +12,7 @@
 #include "GDCore/Project/ObjectsContainersList.h"
 #include "GDCore/Project/Variable.h"
 #include "GDCore/Project/VariablesContainer.h"
+#include "GDCore/Project/EventsBasedObject.h"
 #include "GDCore/String.h"
 
 namespace gd {
@@ -158,38 +159,67 @@ void GroupVariableHelper::ApplyChangesToObjects(
     }
     auto &object = hasObject ? objectsContainer.GetObject(objectName)
                              : globalObjectsContainer.GetObject(objectName);
-    auto &variablesContainer = object.GetVariables();
-    for (const gd::String &variableName : changeset.removedVariableNames) {
-      variablesContainer.Remove(variableName);
+    gd::GroupVariableHelper::ApplyChangesToVariableContainer(
+      groupVariablesContainer, object.GetVariables(), changeset, true);
+  }
+}
+
+void GroupVariableHelper::ApplyChangesToVariants(
+    gd::EventsBasedObject &eventsBasedObject, const gd::String &objectName,
+    const gd::VariablesChangeset &changeset) {
+  auto &defaultVariablesContainer = eventsBasedObject.GetDefaultVariant()
+                                        .GetObjects()
+                                        .GetObject(objectName)
+                                        .GetVariables();
+  for (auto &variant : eventsBasedObject.GetVariants().GetInternalVector()) {
+    if (!variant->GetObjects().HasObjectNamed(objectName)) {
+      continue;
     }
-    for (const gd::String &variableName : changeset.addedVariableNames) {
-      if (variablesContainer.Has(variableName)) {
-        // It can happens if an object already had the variable but it was not
-        // shared by other object of the group.
-        continue;
-      }
-      variablesContainer.Insert(variableName,
-                                groupVariablesContainer.Get(variableName),
-                                variablesContainer.Count());
+    auto &object = variant->GetObjects().GetObject(objectName);
+    gd::GroupVariableHelper::ApplyChangesToVariableContainer(
+        defaultVariablesContainer, object.GetVariables(), changeset, false);
+  }
+}
+
+void GroupVariableHelper::ApplyChangesToVariableContainer(
+    const gd::VariablesContainer &originalVariablesContainer,
+    gd::VariablesContainer &destinationVariablesContainer,
+    const gd::VariablesChangeset &changeset, bool shouldApplyValueChanges) {
+  for (const gd::String &variableName : changeset.removedVariableNames) {
+    destinationVariablesContainer.Remove(variableName);
+  }
+  for (const gd::String &variableName : changeset.addedVariableNames) {
+    if (destinationVariablesContainer.Has(variableName)) {
+      // It can happens if an object already had the variable but it was not
+      // shared by other object of the group.
+      continue;
     }
-    for (const auto &pair : changeset.oldToNewVariableNames) {
-      const gd::String &oldVariableName = pair.first;
-      const gd::String &newVariableName = pair.second;
-      if (variablesContainer.Has(newVariableName)) {
-        // It can happens if an object already had the variable but it was not
-        // shared by other object of the group.
-        variablesContainer.Remove(oldVariableName);
-      } else {
-        variablesContainer.Rename(oldVariableName, newVariableName);
-      }
+    destinationVariablesContainer.Insert(
+        variableName, originalVariablesContainer.Get(variableName),
+        destinationVariablesContainer.Count());
+  }
+  for (const auto &pair : changeset.oldToNewVariableNames) {
+    const gd::String &oldVariableName = pair.first;
+    const gd::String &newVariableName = pair.second;
+    if (destinationVariablesContainer.Has(newVariableName)) {
+      // It can happens if an object already had the variable but it was not
+      // shared by other object of the group.
+      destinationVariablesContainer.Remove(oldVariableName);
+    } else {
+      destinationVariablesContainer.Rename(oldVariableName, newVariableName);
     }
-    // Apply type and value changes
-    for (const gd::String &variableName : changeset.valueChangedVariableNames) {
-      size_t index = variablesContainer.GetPosition(variableName);
-      variablesContainer.Remove(variableName);
-      variablesContainer.Insert(
-          variableName, groupVariablesContainer.Get(variableName), index);
+  }
+  // Apply type and value changes
+  for (const gd::String &variableName : changeset.valueChangedVariableNames) {
+    if (!shouldApplyValueChanges &&
+        destinationVariablesContainer.Get(variableName).GetType() ==
+            originalVariablesContainer.Get(variableName).GetType()) {
+      continue;
     }
+    size_t index = destinationVariablesContainer.GetPosition(variableName);
+    destinationVariablesContainer.Remove(variableName);
+    destinationVariablesContainer.Insert(
+        variableName, originalVariablesContainer.Get(variableName), index);
   }
 }
 

Core/GDCore/IDE/GroupVariableHelper.h

@@ -12,11 +12,13 @@ class ObjectsContainersList;
 class ObjectsContainer;
 class ObjectGroup;
 class VariablesContainer;
+class EventsBasedObject;
 struct VariablesChangeset;
 } // namespace gd
 
 namespace gd {
 
+// TODO Rename this class as it's also used for variants.
 /**
  * Help handling variables of group objects as a whole.
  *
@@ -70,6 +72,20 @@ class GD_CORE_API GroupVariableHelper {
                         const gd::VariablesContainer &groupVariablesContainer,
                         const gd::ObjectGroup &objectGroup,
                         const gd::VariablesChangeset &changeset);
+
+  /**
+   * @brief Apply the changes done on events-based object child to all its
+   * variants.
+   */
+  static void ApplyChangesToVariants(gd::EventsBasedObject &eventsBasedObject,
+                                     const gd::String &objectName,
+                                     const gd::VariablesChangeset &changeset);
+
+private:
+  static void ApplyChangesToVariableContainer(
+      const gd::VariablesContainer &originalVariablesContainer,
+      gd::VariablesContainer &destinationVariablesContainer,
+      const gd::VariablesChangeset &changeset, bool shouldApplyValueChanges);
 };
 
 } // namespace gd

GDevelop.js/Bindings/Bindings.idl

@@ -372,6 +372,10 @@ interface GroupVariableHelper {
         [Ref] ObjectsContainer globalObjectsContainer,
         [Ref] ObjectsContainer objectsContainer,
         [Const, Ref] ObjectGroup objectGroup);
+    void STATIC_ApplyChangesToVariants(
+        [Ref] EventsBasedObject eventsBasedObject,
+        [Const] DOMString objectName,
+        [Const, Ref] VariablesChangeset changeset);
 };
 
 interface ObjectGroupsContainer {

GDevelop.js/Bindings/Wrapper.cpp

@@ -723,6 +723,7 @@ typedef ExtensionAndMetadata<ExpressionMetadata> ExtensionAndExpressionMetadata;
   ComputeChangesetForVariablesContainer
 #define STATIC_MergeVariableContainers MergeVariableContainers
 #define STATIC_FillAnyVariableBetweenObjects FillAnyVariableBetweenObjects
+#define STATIC_ApplyChangesToVariants ApplyChangesToVariants
 #define STATIC_RenameEventsFunctionsExtension RenameEventsFunctionsExtension
 #define STATIC_UpdateExtensionNameInEventsBasedBehavior \
   UpdateExtensionNameInEventsBasedBehavior

GDevelop.js/types.d.ts

@@ -384,6 +384,7 @@ export class ObjectGroup extends EmscriptenObject {
 export class GroupVariableHelper extends EmscriptenObject {
   static mergeVariableContainers(objectsContainersList: ObjectsContainersList, objectGroup: ObjectGroup): VariablesContainer;
   static fillAnyVariableBetweenObjects(globalObjectsContainer: ObjectsContainer, objectsContainer: ObjectsContainer, objectGroup: ObjectGroup): void;
+  static applyChangesToVariants(eventsBasedObject: EventsBasedObject, objectName: string, changeset: VariablesChangeset): void;
 }
 
 export class ObjectGroupsContainer extends EmscriptenObject {

GDevelop.js/types/gdgroupvariablehelper.js

@@ -2,6 +2,7 @@
 declare class gdGroupVariableHelper {
   static mergeVariableContainers(objectsContainersList: gdObjectsContainersList, objectGroup: gdObjectGroup): gdVariablesContainer;
   static fillAnyVariableBetweenObjects(globalObjectsContainer: gdObjectsContainer, objectsContainer: gdObjectsContainer, objectGroup: gdObjectGroup): void;
+  static applyChangesToVariants(eventsBasedObject: gdEventsBasedObject, objectName: string, changeset: gdVariablesChangeset): void;
   delete(): void;
   ptr: number;
 };

newIDE/app/src/ObjectEditor/ObjectEditorDialog.js

@@ -159,6 +159,13 @@ const InnerDialog = (props: InnerDialogProps) => {
       changeset,
       originalSerializedVariables
     );
+    if (eventsBasedObject) {
+      gd.GroupVariableHelper.applyChangesToVariants(
+        eventsBasedObject,
+        object.getName(),
+        changeset
+      );
+    }
     object.clearPersistentUuid();
 
     // Do the renaming *after* applying changes, as "withSerializableObject"