Fix VariantManager.getVariant() and simplify NozzleModel

CURA-4606

cura/Machines/Models/NozzleModel.py

@@ -21,28 +21,32 @@ class NozzleModel(ListModel):
         self.addRoleName(self.HotendNameRole, "hotend_name")
         self.addRoleName(self.ContainerNodeRole, "container_node")
 
-        Application.getInstance().globalContainerStackChanged.connect(self._update)
-        Application.getInstance().getMachineManager().activeVariantChanged.connect(self._update)
-        Application.getInstance().getMachineManager().activeStackChanged.connect(self._update)
-        Application.getInstance().getMachineManager().activeMaterialChanged.connect(self._update)
+        self._application = Application.getInstance()
+        self._machine_manager = self._application.getMachineManager()
+        self._variant_manager = self._application.getVariantManager()
+
+        self._machine_manager.globalContainerChanged.connect(self._update)
+        self._machine_manager.activeVariantChanged.connect(self._update)
+        self._machine_manager.activeStackChanged.connect(self._update)
+        self._machine_manager.activeMaterialChanged.connect(self._update)
 
     def _update(self):
         Logger.log("d", "Updating {model_class_name}.".format(model_class_name = self.__class__.__name__))
 
         self.items.clear()
 
-        variant_manager = Application.getInstance()._variant_manager
-        active_global_stack = Application.getInstance().getMachineManager()._global_container_stack
-        if active_global_stack is None:
+        global_stack = self._machine_manager.activeMachine
+        if global_stack is None:
             self.setItems([])
             return
 
-        has_variants = parseBool(active_global_stack.getMetaDataEntry("has_variants", False))
+        has_variants = parseBool(global_stack.getMetaDataEntry("has_variants", False))
         if not has_variants:
             self.setItems([])
             return
 
-        variant_node_dict = variant_manager.getVariantNodes(active_global_stack)
+        from cura.Machines.VariantManager import VariantType
+        variant_node_dict = self._variant_manager.getVariantNodes(global_stack, VariantType.NOZZLE)
         if not variant_node_dict:
             self.setItems([])
             return

cura/Machines/VariantManager.py

@@ -83,11 +83,19 @@ class VariantManager:
     # Almost the same as getVariantMetadata() except that this returns an InstanceContainer if present.
     #
     def getVariantNode(self, machine_definition_id: str, variant_name: str,
-                       variant_type: Optional["VariantType"] = VariantType.NOZZLE) -> Optional["ContainerNode"]:
+                       variant_type: Optional["VariantType"] = None) -> Optional["ContainerNode"]:
+        if variant_type is None:
+            variant_node = None
+            variant_type_dict = self._machine_to_variant_dict_map[machine_definition_id]
+            for variant_dict in variant_type_dict.values():
+                if variant_name in variant_dict:
+                    variant_node = variant_dict[variant_name]
+                    break
+            return variant_node
         return self._machine_to_variant_dict_map[machine_definition_id].get(variant_type, {}).get(variant_name)
 
     def getVariantNodes(self, machine: "GlobalStack",
-                        variant_type: Optional["VariantType"] = VariantType.NOZZLE) -> dict:
+                        variant_type: Optional["VariantType"] = None) -> dict:
         machine_definition_id = machine.definition.getId()
         return self._machine_to_variant_dict_map.get(machine_definition_id, {}).get(variant_type, {})