def __init__(self, application: "QtApplication") -> None:
if ContainerRegistry.__instance is not None:
raise RuntimeError("Try to create singleton '%s' more than once" % self.__class__.__name__)
ContainerRegistry.__instance = self
super().__init__()
self._application = application # type: QtApplication
self._emptyInstanceContainer = empty_container # type: InstanceContainer
# Sorted list of container providers (keep it sorted by sorting each time you add one!).
self._providers = [] # type: List[ContainerProvider]
PluginRegistry.addType("container_provider", self.addProvider)
self.metadata = {} # type: Dict[str, Dict[str, Any]]
self._containers = {} # type: Dict[str, ContainerInterface]
self._wrong_container_ids = set() # type: Set[str] # Set of already known wrong containers that must be skipped
self.source_provider = {} # type: Dict[str, Optional[ContainerProvider]] # Where each container comes from.
# Ensure that the empty container is added to the ID cache.
self.metadata["empty"] = self._emptyInstanceContainer.getMetaData()
self._containers["empty"] = self._emptyInstanceContainer
self.source_provider["empty"] = None
self._resource_types = {"definition": Resources.DefinitionContainers} # type: Dict[str, int]
self._query_cache = collections.OrderedDict() # type: collections.OrderedDict # This should really be an ordered set but that does not exist...
#Since queries are based on metadata, we need to make sure to clear the cache when a container's metadata changes.
self.containerMetaDataChanged.connect(self._clearQueryCache)
def __init__(self, application: Application) -> None:
if VersionUpgradeManager.__instance is not None:
raise RuntimeError("Try to create singleton '%s' more than once" % self.__class__.__name__)
VersionUpgradeManager.__instance = self
super().__init__()
self._application = application
self._version_upgrades = {} # type: Dict[Tuple[str, int], Set[Tuple[str, int, Callable[[str, List[str]], Optional[Tuple[List[str], List[str]]]]]]] # For each config type and each version, gives a set of upgrade plug-ins that can convert them to something else.
# For each config type, gives a function with which to get the version number from those files.
self._get_version_functions = {} # type: Dict[str, Callable[[str], int]]
# For each config type, a set of storage paths to search for old config files.
self._storage_paths = {} # type: Dict[str, Dict[int, Set[str]]]
# To know which preference versions and types to upgrade to.
self._current_versions = {} # type: Dict[Tuple[str, int], Any]
self._upgrade_tasks = collections.deque() # type: collections.deque # The files that we still have to upgrade.
self._upgrade_routes = {} # type: Dict[Tuple[str, int], Tuple[str, int, Callable[[str, List[str]], Optional[Tuple[List[str], List[str]]]]]] #How to upgrade from one version to another. Needs to be pre-computed after all version upgrade plug-ins are registered.
self._registry = PluginRegistry.getInstance() # type: PluginRegistry
PluginRegistry.addType("version_upgrade", self._addVersionUpgrade)
#Regular expressions of the files that should not be checked, such as log files.
self._ignored_files = ["^.*\.lock$", "^plugins\.json$", "^packages.json$", "^.*\.log$"] # type: List[str]
def __init__(self):
super().__init__()
self._mesh_readers = {}
self._mesh_writers = {}
PluginRegistry.addType("mesh_writer", self.addWriter)
PluginRegistry.addType("mesh_reader", self.addReader)
def __init__(self):
super().__init__()
self._mesh_readers = {}
self._mesh_writers = {}
PluginRegistry.addType("mesh_writer", self.addWriter)
PluginRegistry.addType("mesh_reader", self.addReader)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._emptyInstanceContainer = _EmptyInstanceContainer("empty")
#Sorted list of container providers (keep it sorted by sorting each time you add one!).
self._providers = [] # type: List[ContainerProvider]
PluginRegistry.addType("container_provider", self.addProvider)
self.metadata = {} # type: Dict[str, Dict[str, Any]]
self._containers = {} # type: Dict[str, ContainerInterface]
self._wrong_container_ids = set(
) # type: Set[str] # Set of already known wrong containers that must be skipped
self.source_provider = {
} # type: Dict[str, Optional[ContainerProvider]] #Where each container comes from.
# Ensure that the empty container is added to the ID cache.
self.metadata["empty"] = self._emptyInstanceContainer.getMetaData()
self._containers["empty"] = self._emptyInstanceContainer
self.source_provider["empty"] = None
self._resource_types = {
"definition": Resources.DefinitionContainers
} # type: Dict[str, int]
self._query_cache = collections.OrderedDict(
) #type: collections.OrderedDict # This should really be an ordered set but that does not exist...
#Since queries are based on metadata, we need to make sure to clear the cache when a container's metadata changes.
self.containerMetaDataChanged.connect(self._clearQueryCache)
def __init__(self, application: "QtApplication") -> None:
if ContainerRegistry.__instance is not None:
raise RuntimeError("Try to create singleton '%s' more than once" %
self.__class__.__name__)
ContainerRegistry.__instance = self
super().__init__()
self._application = application # type: QtApplication
self._emptyInstanceContainer = empty_container # type: InstanceContainer
# Sorted list of container providers (keep it sorted by sorting each time you add one!).
self._providers = [] # type: List[ContainerProvider]
PluginRegistry.addType("container_provider", self.addProvider)
self.metadata = {} # type: Dict[str, Dict[str, Any]]
self._containers = {} # type: Dict[str, ContainerInterface]
self._wrong_container_ids = set(
) # type: Set[str] # Set of already known wrong containers that must be skipped
self.source_provider = {
} # type: Dict[str, Optional[ContainerProvider]] # Where each container comes from.
# Ensure that the empty container is added to the ID cache.
self.metadata["empty"] = self._emptyInstanceContainer.getMetaData()
self._containers["empty"] = self._emptyInstanceContainer
self.source_provider["empty"] = None
self._resource_types = {
"definition": Resources.DefinitionContainers
} # type: Dict[str, int]
self._query_cache = collections.OrderedDict(
) # type: collections.OrderedDict # This should really be an ordered set but that does not exist...
#Since queries are based on metadata, we need to make sure to clear the cache when a container's metadata changes.
self.containerMetaDataChanged.connect(self._clearQueryCache)
def __init__(self):
super().__init__()
self._workspace_readers = []
self._workspace_writers = []
PluginRegistry.addType("workspace_reader", self.addReader)
PluginRegistry.addType("workspace_writer", self.addWriter)
def __init__(self):
super().__init__()
self._workspace_readers = {}
self._workspace_writers = {}
PluginRegistry.addType("workspace_readers", self.addReader)
PluginRegistry.addType("workspace_writers", self.addWriter)
def __init__(self, current_versions):
self._version_upgrades = {} #For each config type and each version, gives a set of upgrade plug-ins that can convert them to something else.
self._get_version_functions = {} #For each config type, gives a function with which to get the version number from those files.
self._storage_paths = {} #For each config type, a set of storage paths to search for old config files.
self._current_versions = current_versions #To know which preference versions and types to upgrade to.
self._registry = PluginRegistry.getInstance()
PluginRegistry.addType("version_upgrade", self._addVersionUpgrade)
def __init__(self) -> None:
super().__init__()
self._output_devices = {} # type: Dict[str, OutputDevice]
self._plugins = {} # type: Dict[str, OutputDevicePlugin]
self._active_device = None # type: Optional[OutputDevice]
self._active_device_override = False
self._write_in_progress = False
PluginRegistry.addType("output_device", self.addOutputDevicePlugin)
def __init__(self):
super().__init__()
self._output_devices = {}
self._plugins = {}
self._active_device = None
self._active_device_override = False
self._write_in_progress = False
PluginRegistry.addType("output_device", self.addOutputDevicePlugin)
def __init__(self):
super().__init__()
self._output_devices = {}
self._plugins = {}
self._active_device = None
self._active_device_override = False
self._write_in_progress = False
PluginRegistry.addType("output_device", self.addOutputDevicePlugin)
def __init__(self):
self._version_upgrades = {} #For each config type and each version, gives a set of upgrade plug-ins that can convert them to something else.
self._get_version_functions = {} #For each config type, gives a function with which to get the version number from those files.
self._storage_paths = {} #For each config type, a set of storage paths to search for old config files.
self._current_versions = {} #To know which preference versions and types to upgrade to.
self._upgrade_tasks = collections.deque() #The files that we still have to upgrade.
self._upgrade_routes = {} #How to upgrade from one version to another. Needs to be pre-computed after all version upgrade plug-ins are registered.
self._registry = PluginRegistry.getInstance()
PluginRegistry.addType("version_upgrade", self._addVersionUpgrade)
def __init__(self):
self._version_upgrades = {} #For each config type and each version, gives a set of upgrade plug-ins that can convert them to something else.
self._get_version_functions = {} #For each config type, gives a function with which to get the version number from those files.
self._storage_paths = {} #For each config type, a set of storage paths to search for old config files.
self._current_versions = {} #To know which preference versions and types to upgrade to.
self._upgrade_tasks = collections.deque() #The files that we still have to upgrade.
self._upgrade_routes = {} #How to upgrade from one version to another. Needs to be pre-computed after all version upgrade plug-ins are registered.
self._registry = PluginRegistry.getInstance()
PluginRegistry.addType("version_upgrade", self._addVersionUpgrade)
def __init__(self, writer_type, reader_type, parent=None):
super().__init__(parent)
self._readers = {}
self._writers = {}
self._writer_type = writer_type
self._reader_type = reader_type
PluginRegistry.addType(self._writer_type, self.addWriter)
PluginRegistry.addType(self._reader_type, self.addReader)
def __init__(self, current_versions):
self._version_upgrades = {
} #For each config type and each version, gives a set of upgrade plug-ins that can convert them to something else.
self._get_version_functions = {
} #For each config type, gives a function with which to get the version number from those files.
self._storage_paths = {
} #For each config type, a set of storage paths to search for old config files.
self._current_versions = current_versions #To know which preference versions and types to upgrade to.
self._registry = PluginRegistry.getInstance()
PluginRegistry.addType("version_upgrade", self._addVersionUpgrade)
def __init__(self) -> None:
super().__init__()
self._output_devices = {} # type: Dict[str, OutputDevice]
self._plugins = {} # type: Dict[str, OutputDevicePlugin]
self._active_device = None # type: Optional[OutputDevice]
self._active_device_override = False
self._write_in_progress = False
PluginRegistry.addType("output_device", self.addOutputDevicePlugin)
self._is_running = False
def __init__(self, writer_type: str, reader_type: str, parent = None):
super().__init__(parent)
self._readers = {} # type: Dict[str, MeshReader]
self._writers = {} # type: Dict[str, MeshWriter]
self._writer_type = writer_type # type: str
self._reader_type = reader_type # type: str
PluginRegistry.addType(self._writer_type, self.addWriter)
PluginRegistry.addType(self._reader_type, self.addReader)
def __init__(self, writer_type, reader_type, parent = None):
super().__init__(parent)
self._readers = {}
self._writers = {}
self._writer_type = writer_type
self._reader_type = reader_type
PluginRegistry.addType(self._writer_type, self.addWriter)
PluginRegistry.addType(self._reader_type, self.addReader)
def __init__(self, application: Application) -> None:
"""Initialises the version upgrade manager.
This initialises the cache for shortest upgrade routes, and registers
the version upgrade plug-ins.
"""
if VersionUpgradeManager.__instance is not None:
raise RuntimeError("Try to create singleton '%s' more than once" %
self.__class__.__name__)
VersionUpgradeManager.__instance = self
super().__init__()
self._application = application
self._version_upgrades = {
} # type: Dict[Tuple[str, int], Set[Tuple[str, int, Callable[[str, str], Optional[Tuple[List[str], List[str]]]]]]] # For each config type and each version, gives a set of upgrade plug-ins that can convert them to something else.
# For each config type, gives a function with which to get the version number from those files.
self._get_version_functions = {
} # type: Dict[str, Callable[[str], int]]
# For each config type, a set of storage paths to search for old config files.
self._storage_paths = {} # type: Dict[str, Dict[int, Set[str]]]
# To know which preference versions and types to upgrade to.
self._current_versions = {} # type: Dict[Tuple[str, int], Any]
self._upgrade_tasks = collections.deque(
) # type: collections.deque # The files that we still have to upgrade.
self._upgrade_routes = {
} # type: Dict[Tuple[str, int], Tuple[str, int, Callable[[str, str], Optional[Tuple[List[str], List[str]]]]]] #How to upgrade from one version to another. Needs to be pre-computed after all version upgrade plug-ins are registered.
self._registry = PluginRegistry.getInstance() # type: PluginRegistry
PluginRegistry.addType("version_upgrade", self._addVersionUpgrade)
#Regular expressions of the files that should not be checked, such as log files.
self._ignored_files = [
".*\.lock", # Don't upgrade the configuration file lock. It's not persistent.
"plugins\.json", # plugins.json and packages.json need to remain the same for the version upgrade plug-ins.
"packages\.json",
".*\.log", # Don't process the log. It's not needed and it could be really big.
".*\.log.?", # Don't process the backup of the log. It's not needed and it could be really big.
"3.[0-3]\\.*", # Don't upgrade folders that are back-ups from older version upgrades. Until v3.3 we stored the back-up in the config folder itself.
"3.[0-3]/.*",
"2.[0-7]\\.*",
"2.[0-7]/.*",
"cura\\.*",
"cura/.*",
"plugins\\.*", # Don't upgrade manually installed plug-ins.
"plugins/.*",
"./*packages\.json",
"./*plugins\.json"
] # type: List[str]
def initialize(self):
container_registry = self._application.getContainerRegistry()
# Add machine_action as plugin type
PluginRegistry.addType("machine_action", self.addMachineAction)
# Ensure that all containers that were registered before creation of this registry are also handled.
# This should not have any effect, but it makes it safer if we ever refactor the order of things.
for container in container_registry.findDefinitionContainers():
self._onContainerAdded(container)
container_registry.containerAdded.connect(self._onContainerAdded)
def __init__(self, application: "Application") -> None:
super().__init__() # Call super to make multiple inheritance work.
self._scene = Scene()
self._application = application
self._active_view = None # type: Optional[View]
self._views = {} # type: Dict[str, View]
self._active_tool = None # type: Optional[Tool]
self._tool_operation_active = False
self._tools = {} # type: Dict[str, Tool]
self._camera_tool = None #type: Optional[Tool]
self._selection_tool = None #type: Optional[Tool]
self._tools_enabled = True #type: bool
self._active_stage = None #type: Optional[Stage]
self._stages = {} #type: Dict[str, Stage]
self._input_devices = {} #type: Dict[str, InputDevice]
PluginRegistry.addType("stage", self.addStage)
PluginRegistry.addType("view", self.addView)
PluginRegistry.addType("tool", self.addTool)
PluginRegistry.addType("input_device", self.addInputDevice)
def __init__(self, application):
super().__init__() # Call super to make multiple inheritance work.
self._scene = Scene()
self._application = application
self._is_model_rendering_enabled = True
self._active_view = None
self._views = {}
self._active_tool = None
self._tool_operation_active = False
self._tools = {}
self._camera_tool = None
self._selection_tool = None
self._tools_enabled = True
self._active_stage = None
self._stages = {}
self._input_devices = {}
PluginRegistry.addType("stage", self.addStage)
PluginRegistry.addType("view", self.addView)
PluginRegistry.addType("tool", self.addTool)
PluginRegistry.addType("input_device", self.addInputDevice)
def __init__(self, application: "Application") -> None:
super().__init__() # Call super to make multiple inheritance work.
self._scene = Scene()
self._application = application
self._active_view = None # type: Optional[View]
self._views = {} # type: Dict[str, View]
self._active_tool = None # type: Optional[Tool]
self._tool_operation_active = False
self._tools = {} # type: Dict[str, Tool]
self._camera_tool = None #type: Optional[Tool]
self._selection_tool = None #type: Optional[Tool]
self._tools_enabled = True #type: bool
self._active_stage = None #type: Optional[Stage]
self._stages = {} #type: Dict[str, Stage]
self._input_devices = {} #type: Dict[str, InputDevice]
PluginRegistry.addType("stage", self.addStage)
PluginRegistry.addType("view", self.addView)
PluginRegistry.addType("tool", self.addTool)
PluginRegistry.addType("input_device", self.addInputDevice)
def __init__(self,
writer_type: str = "unknown_file_writer",
reader_type: str = "unknown_file_reader",
parent: QObject = None) -> None:
super().__init__(parent)
self._readers = {} # type: Dict[str, MeshReader]
self._writers = {} # type: Dict[str, MeshWriter]
self._writer_type = writer_type # type: str
self._reader_type = reader_type # type: str
PluginRegistry.addType(self._writer_type, self.addWriter)
PluginRegistry.addType(self._reader_type, self.addReader)
def __init__(self, application: "QtApplication", writer_type: str = "unknown_file_writer", reader_type: str = "unknown_file_reader", parent: QObject = None) -> None:
if cast(FileHandler, self.__class__).__instance is not None:
raise RuntimeError("Try to create singleton '%s' more than once" % self.__class__.__name__)
cast(FileHandler, self.__class__).__instance = self
super().__init__(parent)
self._application = application
self._readers = {} # type: Dict[str, FileReader]
self._writers = {} # type: Dict[str, FileWriter]
self._writer_type = writer_type # type: str
self._reader_type = reader_type # type: str
PluginRegistry.addType(self._writer_type, self.addWriter)
PluginRegistry.addType(self._reader_type, self.addReader)
def __init__(self, parent = None):
super().__init__(parent)
self._machine_actions = {} # Dict of all known machine actions
self._required_actions = {} # Dict of all required actions by definition ID
self._supported_actions = {} # Dict of all supported actions by definition ID
self._first_start_actions = {} # Dict of all actions that need to be done when first added by definition ID
# Add machine_action as plugin type
PluginRegistry.addType("machine_action", self.addMachineAction)
# Ensure that all containers that were registered before creation of this registry are also handled.
# This should not have any effect, but it makes it safer if we ever refactor the order of things.
for container in ContainerRegistry.getInstance().findDefinitionContainers():
self._onContainerAdded(container)
ContainerRegistry.getInstance().containerAdded.connect(self._onContainerAdded)
def __init__(self, parent = None):
super().__init__(parent)
self._machine_actions = {} # Dict of all known machine actions
self._required_actions = {} # Dict of all required actions by definition ID
self._supported_actions = {} # Dict of all supported actions by definition ID
self._first_start_actions = {} # Dict of all actions that need to be done when first added by definition ID
# Add machine_action as plugin type
PluginRegistry.addType("machine_action", self.addMachineAction)
# Ensure that all containers that were registered before creation of this registry are also handled.
# This should not have any effect, but it makes it safer if we ever refactor the order of things.
for container in ContainerRegistry.getInstance().findDefinitionContainers():
self._onContainerAdded(container)
ContainerRegistry.getInstance().containerAdded.connect(self._onContainerAdded)
def __init__(self, application: "QtApplication") -> None:
if ContainerRegistry.__instance is not None:
raise RuntimeError("Try to create singleton '%s' more than once" %
self.__class__.__name__)
ContainerRegistry.__instance = self
super().__init__()
self._application = application # type: QtApplication
self._emptyInstanceContainer = empty_container # type: InstanceContainer
# Sorted list of container providers (keep it sorted by sorting each time you add one!).
self._providers = [] # type: List[ContainerProvider]
PluginRegistry.addType("container_provider", self.addProvider)
self.metadata = {} # type: Dict[str, metadata_type]
self._containers = {} # type: Dict[str, ContainerInterface]
self._wrong_container_ids = set(
) # type: Set[str] # Set of already known wrong containers that must be skipped
self.source_provider = {
} # type: Dict[str, Optional[ContainerProvider]] # Where each container comes from.
# Ensure that the empty container is added to the ID cache.
self.metadata["empty"] = self._emptyInstanceContainer.getMetaData()
self._containers["empty"] = self._emptyInstanceContainer
self.source_provider["empty"] = None
self._resource_types = {
"definition": Resources.DefinitionContainers
} # type: Dict[str, int]
# Since queries are based on metadata, we need to make sure to clear the cache when a container's metadata
# changes.
self.containerMetaDataChanged.connect(self._clearQueryCache)
# We use a database to store the metadata so that we don't have to extract them from the files every time
# the application starts. Reading the data from a lot of files is especially slow on Windows; about 30x as slow.
self._db_connection: Optional[db.Connection] = None
# Since each container that we can store in the database has different metadata (and thus needs different logic
# to extract it from the database again), we use database controllers to do that. These are set by type; Each
# type of container needs to have their own controller.
self._database_handlers: Dict[
str, DatabaseMetadataContainerController] = {}
self._explicit_read_only_container_ids = set() # type: Set[str]
def __init__(self, application: "QtApplication", writer_type: str = "unknown_file_writer", reader_type: str = "unknown_file_reader", parent: QObject = None) -> None:
if cast(FileHandler, self.__class__).__instance is not None:
raise RuntimeError("Try to create singleton '%s' more than once" % self.__class__.__name__)
cast(FileHandler, self.__class__).__instance = self
super().__init__(parent)
self._application = application
self._readers = {} # type: Dict[str, FileReader]
self._writers = {} # type: Dict[str, FileWriter]
self._writer_type = writer_type # type: str
self._reader_type = reader_type # type: str
self._add_to_recent_files_hints = [] # type: List[QUrl]
PluginRegistry.addType(self._writer_type, self.addWriter)
PluginRegistry.addType(self._reader_type, self.addReader)
def __init__(self, app_name):
super().__init__()
self._application_name = app_name
self._machine_definitions = []
self._machine_instances = []
self._profiles = []
self._active_machine = None
self._active_profile = None
self._profile_readers = {} #Plugins that read profiles from file.
self._profile_writers = {} #Plugins that write profiles to file.
PluginRegistry.addType("profile_reader", self.addProfileReader)
PluginRegistry.addType("profile_writer", self.addProfileWriter)
Preferences.getInstance().addPreference("machines/setting_visibility", "")
Preferences.getInstance().addPreference("machines/active_instance", "")
Preferences.getInstance().addPreference("machines/active_profile", "Normal Quality")
def __init__(self, application: Application) -> None:
if VersionUpgradeManager.__instance is not None:
raise RuntimeError("Try to create singleton '%s' more than once" % self.__class__.__name__)
VersionUpgradeManager.__instance = self
super().__init__()
self._application = application
self._version_upgrades = {} # type: Dict[Tuple[str, int], Set[Tuple[str, int, Callable[[str, List[str]], Optional[Tuple[List[str], List[str]]]]]]] # For each config type and each version, gives a set of upgrade plug-ins that can convert them to something else.
# For each config type, gives a function with which to get the version number from those files.
self._get_version_functions = {} # type: Dict[str, Callable[[str], int]]
# For each config type, a set of storage paths to search for old config files.
self._storage_paths = {} # type: Dict[str, Dict[int, Set[str]]]
# To know which preference versions and types to upgrade to.
self._current_versions = {} # type: Dict[Tuple[str, int], Any]
self._upgrade_tasks = collections.deque() # type: collections.deque # The files that we still have to upgrade.
self._upgrade_routes = {} # type: Dict[Tuple[str, int], Tuple[str, int, Callable[[str, List[str]], Optional[Tuple[List[str], List[str]]]]]] #How to upgrade from one version to another. Needs to be pre-computed after all version upgrade plug-ins are registered.
self._registry = PluginRegistry.getInstance() # type: PluginRegistry
PluginRegistry.addType("version_upgrade", self._addVersionUpgrade)
#Regular expressions of the files that should not be checked, such as log files.
self._ignored_files = [
".*\.lock", # Don't upgrade the configuration file lock. It's not persistent.
"plugins\.json", # plugins.json and packages.json need to remain the same for the version upgrade plug-ins.
"packages\.json",
".*\.log", # Don't process the log. It's not needed and it could be really big.
"3.[0-3]\\.*", # Don't upgrade folders that are back-ups from older version upgrades. Until v3.3 we stored the back-up in the config folder itself.
"3.[0-3]/.*",
"2.[0-7]\\.*",
"2.[0-7]/.*",
"cura\\.*",
"cura/.*",
"plugins\\.*", # Don't upgrade manually installed plug-ins.
"plugins/.*",
] # type: List[str]
def __init__(self, app_name):
super().__init__()
self._application_name = app_name
self._machine_definitions = []
self._machine_instances = []
self._profiles = []
self._active_machine = None
self._active_profile = None
self._profile_readers = {} #Plugins that read profiles from file.
self._profile_writers = {} #Plugins that write profiles to file.
PluginRegistry.addType("profile_reader", self.addProfileReader)
PluginRegistry.addType("profile_writer", self.addProfileWriter)
Preferences.getInstance().addPreference("machines/setting_visibility",
"")
Preferences.getInstance().addPreference("machines/active_instance", "")
Preferences.getInstance().addPreference("machines/active_profile",
"Normal Quality")
def __init__(self, app_name):
super().__init__()
self._application_name = app_name
self._machine_definitions = []
self._machine_instances = []
self._profiles = [
] # All the profiles that are loaded from disk, for any machine instance
self._active_machine = None
self._active_profile = None
self._protect_working_profile = False
self._profile_readers = {} # Plugins that read profiles from file.
self._profile_writers = {} # Plugins that write profiles to file.
PluginRegistry.addType("profile_reader", self.addProfileReader)
PluginRegistry.addType("profile_writer", self.addProfileWriter)
Preferences.getInstance().addPreference("machines/setting_visibility",
"")
Preferences.getInstance().addPreference("machines/active_instance", "")
def __init__(self, application):
super().__init__() # Call super to make multiple inheritence work.
self._active_tool = None
self._tools = {}
self._input_devices = {}
self._active_view = None
self._views = {}
self._scene = Scene()
self._application = application
self._camera_tool = None
self._selection_tool = None
PluginRegistry.addType("view", self.addView)
PluginRegistry.addType("tool", self.addTool)
PluginRegistry.addType("input_device", self.addInputDevice)
def __init__(self, application):
super().__init__() # Call super to make multiple inheritence work.
self._active_tool = None
self._tools = {}
self._input_devices = {}
self._active_view = None
self._views = {}
self._scene = Scene()
self._application = application
self._camera_tool = None
self._selection_tool = None
PluginRegistry.addType("view", self.addView)
PluginRegistry.addType("tool", self.addTool)
PluginRegistry.addType("input_device", self.addInputDevice)
__instance = None # type: ContainerRegistry
__container_types = {
"definition": DefinitionContainer,
"instance": InstanceContainer,
"stack": ContainerStack,
}
mime_type_map = {
"application/x-uranium-definitioncontainer": DefinitionContainer,
"application/x-uranium-instancecontainer": InstanceContainer,
"application/x-uranium-containerstack": ContainerStack,
"application/x-uranium-extruderstack": ContainerStack
}
PluginRegistry.addType("settings_container", ContainerRegistry.addContainerType)
class _EmptyInstanceContainer(InstanceContainer):
def isDirty(self) -> bool:
return False
def getProperty(self, key, property_name, context = None):
return None
def setProperty(self, key, property_name, property_value, container = None, set_from_cache = False):
Logger.log("e", "Setting property %s of container %s which should remain empty", key, self.getName())
return
def getConfigurationType(self) -> str:
return "" # FIXME: not sure if this is correct
def __init__(self, name, version, buildtype = "", **kwargs):
if Application._instance != None:
raise ValueError("Duplicate singleton creation")
# If the constructor is called and there is no instance, set the instance to self.
# This is done because we can't make constructor private
Application._instance = self
self._application_name = name
self._version = version
self._buildtype = buildtype
os.putenv("UBUNTU_MENUPROXY", "0") # For Ubuntu Unity this makes Qt use its own menu bar rather than pass it on to Unity.
Signal._app = self
Resources.ApplicationIdentifier = name
i18nCatalog.setApplication(self)
Resources.addSearchPath(os.path.join(os.path.dirname(sys.executable), "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "share", "uranium", "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "Resources", "uranium", "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "Resources", self.getApplicationName(), "resources"))
if not hasattr(sys, "frozen"):
Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources"))
self._main_thread = threading.current_thread()
super().__init__() # Call super to make multiple inheritance work.
self._renderer = None
PluginRegistry.addType("backend", self.setBackend)
PluginRegistry.addType("logger", Logger.addLogger)
PluginRegistry.addType("extension", self.addExtension)
preferences = Preferences.getInstance()
preferences.addPreference("general/language", "en")
preferences.addPreference("general/visible_settings", "")
try:
preferences.readFromFile(Resources.getPath(Resources.Preferences, self._application_name + ".cfg"))
except FileNotFoundError:
pass
self._controller = Controller(self)
self._mesh_file_handler = MeshFileHandler()
self._extensions = []
self._backend = None
self._output_device_manager = OutputDeviceManager()
self._required_plugins = []
self._operation_stack = OperationStack()
self._plugin_registry = PluginRegistry.getInstance()
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "lib", "uranium"))
self._plugin_registry.addPluginLocation(os.path.join(os.path.dirname(sys.executable), "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "Resources", "uranium", "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "Resources", self.getApplicationName(), "plugins"))
# Locally installed plugins
self._plugin_registry.addPluginLocation(os.path.join(Resources.getStoragePath(Resources.Resources), "plugins"))
if not hasattr(sys, "frozen"):
self._plugin_registry.addPluginLocation(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "plugins"))
self._plugin_registry.setApplication(self)
self._parsed_command_line = None
self.parseCommandLine()
self._visible_messages = []
self._message_lock = threading.Lock()
self.showMessageSignal.connect(self.showMessage)
self.hideMessageSignal.connect(self.hideMessage)
self._global_container_stack = None
def __init__(self, name, version, **kwargs):
if (Application._instance != None):
raise ValueError("Duplicate singleton creation")
# If the constructor is called and there is no instance, set the instance to self.
# This is done because we can't make constructor private
Application._instance = self
self._application_name = name
self._version = version
os.putenv(
"UBUNTU_MENUPROXY", "0"
) #For Ubuntu Unity this makes Qt use its own menu bar rather than pass it on to Unity.
Signal._app = self
Resources.ApplicationIdentifier = name
i18nCatalog.setApplication(self)
Resources.addSearchPath(os.path.dirname(sys.executable))
Resources.addSearchPath(
os.path.join(Application.getInstallPrefix(), "share", "uranium"))
Resources.addSearchPath(
os.path.join(Application.getInstallPrefix(), "Resources",
"uranium"))
Resources.addSearchPath(
os.path.join(Application.getInstallPrefix(), "Resources",
self.getApplicationName()))
if not hasattr(sys, "frozen"):
Resources.addSearchPath(
os.path.join(os.path.abspath(os.path.dirname(__file__)), ".."))
self._main_thread = threading.current_thread()
super().__init__(
**kwargs) # Call super to make multiple inheritence work.
self._renderer = None
PluginRegistry.addType("backend", self.setBackend)
PluginRegistry.addType("logger", Logger.addLogger)
PluginRegistry.addType("extension", self.addExtension)
preferences = Preferences.getInstance()
preferences.addPreference("general/language", "en")
try:
preferences.readFromFile(
Resources.getPath(Resources.Preferences,
self._application_name + ".cfg"))
except FileNotFoundError:
pass
self._controller = Controller(self)
self._mesh_file_handler = MeshFileHandler()
self._extensions = []
self._backend = None
self._output_device_manager = OutputDeviceManager()
self._machine_manager = MachineManager(self._application_name)
self._required_plugins = []
self._operation_stack = OperationStack()
self._plugin_registry = PluginRegistry.getInstance()
self._plugin_registry.addPluginLocation(
os.path.join(Application.getInstallPrefix(), "lib", "uranium"))
self._plugin_registry.addPluginLocation(
os.path.join(os.path.dirname(sys.executable), "plugins"))
self._plugin_registry.addPluginLocation(
os.path.join(Application.getInstallPrefix(), "Resources",
"uranium", "plugins"))
self._plugin_registry.addPluginLocation(
os.path.join(Application.getInstallPrefix(), "Resources",
self.getApplicationName(), "plugins"))
# Locally installed plugins
self._plugin_registry.addPluginLocation(
os.path.join(Resources.getStoragePath(Resources.Resources),
"plugins"))
if not hasattr(sys, "frozen"):
self._plugin_registry.addPluginLocation(
os.path.join(os.path.abspath(os.path.dirname(__file__)), "..",
"plugins"))
self._plugin_registry.setApplication(self)
self._parsed_command_line = None
self.parseCommandLine()
self._visible_messages = []
self._message_lock = threading.Lock()
self.showMessageSignal.connect(self.showMessage)
self.hideMessageSignal.connect(self.hideMessage)
def initialize(self) -> None:
# Add machine_action as plugin type
PluginRegistry.addType("machine_action", self.addMachineAction)
def __init__(self, name, version, **kwargs):
if(Application._instance != None):
raise ValueError("Duplicate singleton creation")
# If the constructor is called and there is no instance, set the instance to self.
# This is done because we can't make constructor private
Application._instance = self
self._application_name = name
self._version = version
Signal._app = self
Resources.ApplicationIdentifier = name
Resources.addResourcePath(os.path.dirname(sys.executable))
Resources.addResourcePath(os.path.join(Application.getInstallPrefix(), "share", "uranium"))
Resources.addResourcePath(os.path.join(Application.getInstallPrefix(), "Resources", "uranium"))
Resources.addResourcePath(os.path.join(Application.getInstallPrefix(), "Resources", self.getApplicationName()))
if not hasattr(sys, "frozen"):
Resources.addResourcePath(os.path.join(os.path.abspath(os.path.dirname(__file__)), ".."))
self._main_thread = threading.current_thread()
super().__init__(**kwargs) # Call super to make multiple inheritence work.
self._renderer = None
PluginRegistry.addType("storage_device", self.addStorageDevice)
PluginRegistry.addType("backend", self.setBackend)
PluginRegistry.addType("logger", Logger.addLogger)
PluginRegistry.addType("extension", self.addExtension)
preferences = Preferences.getInstance()
preferences.addPreference("general/language", "en")
try:
preferences.readFromFile(Resources.getPath(Resources.PreferencesLocation, self._application_name + ".cfg"))
except FileNotFoundError:
pass
self._controller = Controller(self)
self._mesh_file_handler = MeshFileHandler()
self._workspace_file_handler = WorkspaceFileHandler()
self._storage_devices = {}
self._extensions = []
self._backend = None
self._machines = []
self._active_machine = None
self._required_plugins = []
self._operation_stack = OperationStack()
self._plugin_registry = PluginRegistry.getInstance()
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "lib", "uranium"))
self._plugin_registry.addPluginLocation(os.path.join(os.path.dirname(sys.executable), "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "Resources", "uranium", "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "Resources", self.getApplicationName(), "plugins"))
# Locally installed plugins
self._plugin_registry.addPluginLocation(os.path.join(Resources.getStoragePath(Resources.ResourcesLocation), "plugins"))
if not hasattr(sys, "frozen"):
self._plugin_registry.addPluginLocation(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "plugins"))
self._plugin_registry.setApplication(self)
self._parsed_command_line = None
self.parseCommandLine()
self._visible_messages = []
self._message_lock = threading.Lock()
self.showMessageSignal.connect(self.showMessage)
self.hideMessageSignal.connect(self.hideMessage)
## Context manager to create a lock file for the cache directory and remove
# it afterwards.
def lockCache(self) -> LockFile:
return LockFile(
self.getCacheLockFilename(),
timeout = 10,
wait_msg = "Waiting for lock file in cache directory to disappear."
)
__container_types = {
"definition": DefinitionContainer,
"instance": InstanceContainer,
"stack": ContainerStack,
}
mime_type_map = {
"application/x-uranium-definitioncontainer": DefinitionContainer,
"application/x-uranium-instancecontainer": InstanceContainer,
"application/x-uranium-containerstack": ContainerStack,
"application/x-uranium-extruderstack": ContainerStack
} # type: Dict[str, Type[ContainerInterface]]
__instance = None # type: ContainerRegistry
@classmethod
def getInstance(cls, *args, **kwargs) -> "ContainerRegistry":
return cls.__instance
PluginRegistry.addType("settings_container", ContainerRegistry.addContainerType)
def __init__(self, name: str, version: str, build_type: str = "", **kwargs):
if Application._instance != None:
raise ValueError("Duplicate singleton creation")
# If the constructor is called and there is no instance, set the instance to self.
# This is done because we can't make constructor private
Application._instance = self
self._application_name = name
self._version = version
self._build_type = build_type
os.putenv("UBUNTU_MENUPROXY", "0") # For Ubuntu Unity this makes Qt use its own menu bar rather than pass it on to Unity.
Signal._app = self
Signal._signalQueue = self
Resources.ApplicationIdentifier = name
Resources.ApplicationVersion = version
Resources.addSearchPath(os.path.join(os.path.dirname(sys.executable), "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "share", "uranium", "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "Resources", "uranium", "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "Resources", self.getApplicationName(), "resources"))
#Fixme:CuraApplication will add the path again, so comment this
# if not hasattr(sys, "frozen"):
# Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources"))
self._main_thread = threading.current_thread()
super().__init__() # Call super to make multiple inheritance work.
i18nCatalog.setApplication(self)
self._renderer = None
PluginRegistry.addType("backend", self.setBackend)
PluginRegistry.addType("logger", Logger.addLogger)
PluginRegistry.addType("extension", self.addExtension)
preferences = Preferences.getInstance()
preferences.addPreference("general/language", "en")
preferences.addPreference("general/visible_settings", "")
try:
preferences.readFromFile(Resources.getPath(Resources.Preferences, self._application_name + ".cfg"))
except FileNotFoundError:
pass
self._controller = Controller(self)
self._mesh_file_handler = MeshFileHandler.getInstance()
self._mesh_file_handler.setApplication(self)
self._workspace_file_handler = WorkspaceFileHandler.getInstance()
self._workspace_file_handler.setApplication(self)
self._extensions = []
self._backend = None
self._output_device_manager = OutputDeviceManager()
self._required_plugins = []
self._operation_stack = OperationStack(self.getController())
self._plugin_registry = PluginRegistry.getInstance()
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "lib", "uranium"))
self._plugin_registry.addPluginLocation(os.path.join(os.path.dirname(sys.executable), "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "Resources", "uranium", "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "Resources", self.getApplicationName(), "plugins"))
# Locally installed plugins
local_path = os.path.join(Resources.getStoragePath(Resources.Resources), "plugins")
# Ensure the local plugins directory exists
try:
os.makedirs(local_path)
except OSError:
pass
self._plugin_registry.addPluginLocation(local_path)
# Fixme:CuraApplication will add the path again, so comment this
# if not hasattr(sys, "frozen"):
# self._plugin_registry.addPluginLocation(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "plugins"))
self._plugin_registry.setApplication(self)
ContainerRegistry.setApplication(self)
UM.Settings.InstanceContainer.setContainerRegistry(self.getContainerRegistry())
UM.Settings.ContainerStack.setContainerRegistry(self.getContainerRegistry())
self._parsed_command_line = None
self.parseCommandLine()
self._visible_messages = []
self._message_lock = threading.Lock()
self.showMessageSignal.connect(self.showMessage)
self.hideMessageSignal.connect(self.hideMessage)
self._global_container_stack = None
def __init__(self, name: str, version: str, build_type: str = "", is_debug_mode: bool = False, parser: argparse.ArgumentParser = None, parsed_command_line: Dict[str, Any] = None, **kwargs) -> None:
if Application._instance is not None:
raise ValueError("Duplicate singleton creation")
if parsed_command_line is None:
parsed_command_line = {}
# If the constructor is called and there is no instance, set the instance to self.
# This is done because we can't make constructor private
Application._instance = self
self._application_name = name #type: str
self._version = version #type: str
self._build_type = build_type #type: str
if "debug" in parsed_command_line.keys():
if not parsed_command_line["debug"] and is_debug_mode:
parsed_command_line["debug"] = is_debug_mode
os.putenv("UBUNTU_MENUPROXY", "0") # For Ubuntu Unity this makes Qt use its own menu bar rather than pass it on to Unity.
Signal._app = self
Signal._signalQueue = self
Resources.ApplicationIdentifier = name
Resources.ApplicationVersion = version
Resources.addSearchPath(os.path.join(os.path.dirname(sys.executable), "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "share", "uranium", "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "Resources", "uranium", "resources"))
Resources.addSearchPath(os.path.join(Application.getInstallPrefix(), "Resources", self.getApplicationName(), "resources"))
if not hasattr(sys, "frozen"):
Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources"))
self._main_thread = threading.current_thread() #type: threading.Thread
super().__init__() # Call super to make multiple inheritance work.
i18nCatalog.setApplication(self)
self._renderer = None #type: Renderer
PluginRegistry.addType("backend", self.setBackend)
PluginRegistry.addType("logger", Logger.addLogger)
PluginRegistry.addType("extension", self.addExtension)
self.default_theme = self.getApplicationName() #type: str
preferences = Preferences.getInstance()
preferences.addPreference("general/language", "en_US")
preferences.addPreference("general/visible_settings", "")
preferences.addPreference("general/plugins_to_remove", "")
preferences.addPreference("general/disabled_plugins", "")
try:
preferences.readFromFile(Resources.getPath(Resources.Preferences, self._application_name + ".cfg"))
except FileNotFoundError:
pass
self._controller = Controller(self) #type: Controller
self._extensions = [] #type: List[Extension]
self._backend = None #type: Backend
self._output_device_manager = OutputDeviceManager() #type: OutputDeviceManager
self._required_plugins = [] #type: List[str]
self._operation_stack = OperationStack(self.getController()) #type: OperationStack
self._plugin_registry = PluginRegistry.getInstance() #type: PluginRegistry
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), UraniumLibraryDir, "uranium"))
self._plugin_registry.addPluginLocation(os.path.join(os.path.dirname(sys.executable), "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "Resources", "uranium", "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(Application.getInstallPrefix(), "Resources", self.getApplicationName(), "plugins"))
# Locally installed plugins
local_path = os.path.join(Resources.getStoragePath(Resources.Resources), "plugins")
# Ensure the local plugins directory exists
try:
os.makedirs(local_path)
except OSError:
pass
self._plugin_registry.addPluginLocation(local_path)
if not hasattr(sys, "frozen"):
self._plugin_registry.addPluginLocation(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "plugins"))
self._plugin_registry.setApplication(self)
ContainerRegistry.setApplication(self)
UM.Settings.InstanceContainer.setContainerRegistry(self.getContainerRegistry())
UM.Settings.ContainerStack.setContainerRegistry(self.getContainerRegistry())
self._command_line_parser = parser #type: argparse.ArgumentParser
self._parsed_command_line = parsed_command_line #type: Dict[str, Any]
self.parseCommandLine()
self._visible_messages = [] #type: List[Message]
self._message_lock = threading.Lock() #type: threading.Lock
self.showMessageSignal.connect(self.showMessage)
self.hideMessageSignal.connect(self.hideMessage)
self._global_container_stack = None #type: ContainerStack
def initialize(self) -> None:
# For Ubuntu Unity this makes Qt use its own menu bar rather than pass it on to Unity.
os.putenv("UBUNTU_MENUPROXY", "0")
# Custom signal handling
Signal._app = self
Signal._signalQueue = self
# Initialize Resources. Set the application name and version here because we can only know the actual info
# after the __init__() has been called.
Resources.ApplicationIdentifier = self._app_name
Resources.ApplicationVersion = self._version
Resources.addSearchPath(
os.path.join(os.path.dirname(sys.executable), "resources"))
Resources.addSearchPath(
os.path.join(self._app_install_dir, "share", "uranium",
"resources"))
Resources.addSearchPath(
os.path.join(self._app_install_dir, "Resources", "uranium",
"resources"))
Resources.addSearchPath(
os.path.join(self._app_install_dir, "Resources", self._app_name,
"resources"))
if not hasattr(sys, "frozen"):
Resources.addSearchPath(
os.path.join(os.path.abspath(os.path.dirname(__file__)), "..",
"resources"))
i18nCatalog.setApplication(self)
PluginRegistry.addType("backend", self.setBackend)
PluginRegistry.addType("logger", Logger.addLogger)
PluginRegistry.addType("extension", self.addExtension)
self._preferences = Preferences()
self._preferences.addPreference("general/language",
self._default_language)
self._preferences.addPreference("general/visible_settings", "")
self._preferences.addPreference("general/plugins_to_remove", "")
self._preferences.addPreference("general/disabled_plugins", "")
self._controller = Controller(self)
self._output_device_manager = OutputDeviceManager()
self._operation_stack = OperationStack(
self._controller) # type: OperationStack
self._plugin_registry = PluginRegistry(self) #type: PluginRegistry
self._plugin_registry.addPluginLocation(
os.path.join(self._app_install_dir, "lib", "uranium"))
self._plugin_registry.addPluginLocation(
os.path.join(self._app_install_dir, "lib64", "uranium"))
self._plugin_registry.addPluginLocation(
os.path.join(self._app_install_dir, "lib32", "uranium"))
self._plugin_registry.addPluginLocation(
os.path.join(os.path.dirname(sys.executable), "plugins"))
self._plugin_registry.addPluginLocation(
os.path.join(self._app_install_dir, "Resources", "uranium",
"plugins"))
self._plugin_registry.addPluginLocation(
os.path.join(self._app_install_dir, "Resources", self._app_name,
"plugins"))
# Locally installed plugins
local_path = os.path.join(
Resources.getStoragePath(Resources.Resources), "plugins")
# Ensure the local plugins directory exists
try:
os.makedirs(local_path)
except OSError:
pass
self._plugin_registry.addPluginLocation(local_path)
if not hasattr(sys, "frozen"):
self._plugin_registry.addPluginLocation(
os.path.join(os.path.abspath(os.path.dirname(__file__)), "..",
"plugins"))
self._container_registry = self._container_registry_class(self)
UM.Settings.InstanceContainer.setContainerRegistry(
self._container_registry)
UM.Settings.ContainerStack.setContainerRegistry(
self._container_registry)
# Initialize the package manager to remove and install scheduled packages.
self._package_manager = self._package_manager_class(self)
self.showMessageSignal.connect(self.showMessage)
self.hideMessageSignal.connect(self.hideMessage)
def initialize(self) -> None:
# For Ubuntu Unity this makes Qt use its own menu bar rather than pass it on to Unity.
os.putenv("UBUNTU_MENUPROXY", "0")
# Custom signal handling
Signal._app = self
Signal._signalQueue = self
# Initialize Resources. Set the application name and version here because we can only know the actual info
# after the __init__() has been called.
Resources.ApplicationIdentifier = self._app_name
Resources.ApplicationVersion = self._version
Resources.addSearchPath(os.path.join(os.path.dirname(sys.executable), "resources"))
Resources.addSearchPath(os.path.join(self._app_install_dir, "share", "uranium", "resources"))
Resources.addSearchPath(os.path.join(self._app_install_dir, "Resources", "uranium", "resources"))
Resources.addSearchPath(os.path.join(self._app_install_dir, "Resources", self._app_name, "resources"))
if not hasattr(sys, "frozen"):
Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources"))
i18nCatalog.setApplication(self)
PluginRegistry.addType("backend", self.setBackend)
PluginRegistry.addType("logger", Logger.addLogger)
PluginRegistry.addType("extension", self.addExtension)
self._preferences = Preferences()
self._preferences.addPreference("general/language", self._default_language)
self._preferences.addPreference("general/visible_settings", "")
self._preferences.addPreference("general/plugins_to_remove", "")
self._preferences.addPreference("general/disabled_plugins", "")
self._controller = Controller(self)
self._output_device_manager = OutputDeviceManager()
self._operation_stack = OperationStack(self._controller) # type: OperationStack
self._plugin_registry = PluginRegistry(self) #type: PluginRegistry
self._plugin_registry.addPluginLocation(os.path.join(self._app_install_dir, "lib", "uranium"))
self._plugin_registry.addPluginLocation(os.path.join(self._app_install_dir, "lib64", "uranium"))
self._plugin_registry.addPluginLocation(os.path.join(self._app_install_dir, "lib32", "uranium"))
self._plugin_registry.addPluginLocation(os.path.join(os.path.dirname(sys.executable), "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(self._app_install_dir, "Resources", "uranium", "plugins"))
self._plugin_registry.addPluginLocation(os.path.join(self._app_install_dir, "Resources", self._app_name, "plugins"))
# Locally installed plugins
local_path = os.path.join(Resources.getStoragePath(Resources.Resources), "plugins")
# Ensure the local plugins directory exists
try:
os.makedirs(local_path)
except OSError:
pass
self._plugin_registry.addPluginLocation(local_path)
if not hasattr(sys, "frozen"):
self._plugin_registry.addPluginLocation(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "plugins"))
self._container_registry = self._container_registry_class(self)
UM.Settings.InstanceContainer.setContainerRegistry(self._container_registry)
UM.Settings.ContainerStack.setContainerRegistry(self._container_registry)
self.showMessageSignal.connect(self.showMessage)
self.hideMessageSignal.connect(self.hideMessage)
def initialize(self):
PluginRegistry.addType("backend", self.addBackendEngine)