Ensemble: Create ensemble scenario from current scenario.

src/Model/Study.py

@@ -679,6 +679,7 @@ class Study(SQLModel):
                     self.status.scenario.y + 100)
 
         new.name = self.status.scenario.name + " (copy)"
+        new.is_ensemble = self.status.scenario.is_ensemble
 
         self.status.scenario = new
         self.river._data_traversal(
@@ -690,15 +691,18 @@ class Study(SQLModel):
         self.status.set_as_editable()
         return new
 
-    def create_ensemble_scenario(self, switch=True):
+    def create_ensemble_scenario(self, pos=None, switch=True):
         new = self.scenarios.new(
             self.status.scenario,
             is_ensemble=True
         )
 
         new.name = self.status.scenario.name + " (ensemble)"
-        new.set_pos(self.status.scenario.x + 100,
+        if pos is not None:
-                    self.status.scenario.y)
+            new.set_pos(pos.x(), pos.y())
+        else:
+            new.set_pos(self.status.scenario.x + 100,
+                        self.status.scenario.y)
 
         if switch:
             self.status.scenario = new

src/View/Scenarios/ContextMenu.py

@@ -47,11 +47,19 @@ class AbstractMenu(object):
 
 class DefaultMenu(AbstractMenu):
     def run(self):
+        current_scenario = self._graph.status.scenario
+
+        if current_scenario.is_ensemble():
+            return
+
         add_node = self._menu.addAction(self._trad["menu_add_scenario"])
+        ensemble = self._menu.addAction(self._trad["menu_ens_scenario"])
 
         action = self._exec()
         if action == add_node:
             self._parent.new_scenario(self._pos)
+        if action == ensemble:
+            self._parent.create_new_ensemble_scenario(self._pos)
 
 
 class ScenarioMenu(AbstractMenu):
@@ -59,17 +67,16 @@ class ScenarioMenu(AbstractMenu):
         item = self._items[0]
         scenarios = item.graph._study.scenarios
 
-        if len(scenarios) == 1:
-            return
-
         current_scenario = item.graph._study.status.scenario.id
 
-        select = self._menu.addAction(self._trad["menu_select_scenario"])
+        select = None
         duplicate = None
         delete = None
-        ensemble = None
         edit_ens = None
 
+        if len(scenarios) > 1:
+            select = self._menu.addAction(self._trad["menu_select_scenario"])
+
         if item.scenario.id != 0:
             if scenarios.is_leaf(item.scenario):
                 delete = self._menu.addAction(self._trad["menu_del_scenario"])
@@ -79,12 +86,6 @@ class ScenarioMenu(AbstractMenu):
                     self._trad["menu_dup_scenario"]
                 )
 
-            if not item.scenario.is_ensemble():
-                if item.scenario.id == current_scenario:
-                    ensemble = self._menu.addAction(
-                        self._trad["menu_ens_scenario"]
-                    )
-
             if item.scenario.is_ensemble():
                 edit_ens = self._menu.addAction(
                     self._trad["menu_edit_ens_scenario"]
@@ -99,7 +100,5 @@ class ScenarioMenu(AbstractMenu):
             self._parent.delete_scenario(item)
         elif action == duplicate:
             self._parent.duplicate_scenario(item)
-        elif action == ensemble:
-            self._parent.create_ensemble_scenario(item)
         elif action == edit_ens:
             self._parent.edit_ensemble_scenario(item)

src/View/Scenarios/GraphWidget.py

@@ -550,6 +550,26 @@ class GraphWidget(QGraphicsView):
         self.exec_with_waiting_window(fn, "create_ensemble_scenario")
         self.changeScenario.emit(self.sender())
 
+    def create_new_ensemble_scenario(self, pos):
+        must_save = self.dialog_save()
+        if must_save == "Cancel":
+            return
+
+        def fn():
+            self._close_other_window()
+
+            if must_save == "Save":
+                self._study.save()
+
+            self._undo.push(
+                CreateEnsembleScenarioCommand(
+                    self._study, pos=pos,
+                )
+            )
+
+        self.exec_with_waiting_window(fn, "create_ensemble_scenario")
+        self.changeScenario.emit(self.sender())
+
     def edit_ensemble_scenario(self, item):
         self.parent\
             .parent\

src/View/Scenarios/UndoCommand.py

@@ -99,11 +99,12 @@ class DuplicateScenariosCommand(QUndoCommand):
 
 
 class CreateEnsembleScenarioCommand(QUndoCommand):
-    def __init__(self, study):
+    def __init__(self, study, pos=None):
         QUndoCommand.__init__(self)
 
         self._study = study
         self._new = None
+        self._pos = pos
 
     def undo(self):
         self._study.scenarios.delete(self._new.id)
@@ -111,7 +112,7 @@ class CreateEnsembleScenarioCommand(QUndoCommand):
 
     def redo(self):
         if self._new is None:
-            self._new = self._study.create_ensemble_scenario()
+            self._new = self._study.create_ensemble_scenario(self._pos)
         else:
             self._new.set_as_not_deleted()
             self._study.reload_from_scenario(self._new)

src/View/Scenarios/translate.py

@@ -44,7 +44,7 @@ class ScenariosTranslate(MainTranslate):
             "Scenarios", "Duplicate this scenario"
         )
         self._dict["menu_ens_scenario"] = _translate(
-            "Scenarios", "Create ensemble scenario from this scenario"
+            "Scenarios", "Create ensemble scenario from current scenario"
         )
         self._dict["menu_edit_ens_scenario"] = _translate(
             "Scenarios", "Edit this ensemble scenario"