def getMetaData():
cura_version = Version(Application.getInstance().getVersion())
tool_icon_path = "resources/icons/tool_icon.svg"
if cura_version < Version("4.11.0") and cura_version.getMajor() > 0:
tool_icon_path = "resources/icons/tool_icon_legacy.svg"
tool_panel_path = "resources/qml/MeasureTool.qml"
if cura_version < Version("5.0.0") and cura_version.getMajor() > 0:
tool_panel_path = "resources/qml_qt5/MeasureTool.qml"
metadata = {
"tool": {
"name":
i18n_catalog.i18nc("@label", "Measure"),
"description":
i18n_catalog.i18nc("@info:tooltip", "Measure parts of objects."),
"icon":
tool_icon_path,
"tool_panel":
tool_panel_path,
"weight":
6,
}
}
return metadata
def __matchVersion():
cura_version = Application.getInstance().getVersion()
if cura_version == "master":
Logger.log("d",
"Running Cura from source, ignoring version of the plugin")
return True
cura_version = Version(cura_version)
cura_version = Version([cura_version.getMajor(), cura_version.getMinor()])
# Get version information from plugin.json
plugin_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"plugin.json")
try:
with open(plugin_file_path) as plugin_file:
plugin_info = json.load(plugin_file)
minimum_cura_version = Version(plugin_info["minimum_cura_version"])
maximum_cura_version = Version(plugin_info["maximum_cura_version"])
except:
Logger.log("w", "Could not get version information for the plugin")
return False
if cura_version >= minimum_cura_version and cura_version <= maximum_cura_version:
return True
else:
Logger.log(
"d",
"This version of the plugin is not compatible with this version of Cura. Please check for an update."
)
return False
def load_window(self):
"""
Create the GUI window for the guide.
The window's QML element is stored in a field. There can only be one
instance at a time.
"""
self.load_definitions()
if self._dialog: # Dialogue already open.
self._dialog.requestActivate() # Bring focus to dialogue.
return
Logger.log("d", "Creating Settings Guide window.")
plugin_path = PluginRegistry.getInstance().getPluginPath(self.getPluginId())
if plugin_path is None:
plugin_path = os.path.dirname(__file__)
application = CuraApplication.getInstance()
version = Version(application.getVersion())
if application.getVersion() != "source" and version.getMajor() <= 4:
path = os.path.join(plugin_path, "resources", "qml_cura4", "SettingsGuide.qml")
else: # In Cura 5+ the QML interface changed significantly, and the settings layout too. We use a different set of QML files to use the new interface and to mimic the new look.
path = os.path.join(plugin_path, "resources", "qml", "SettingsGuide.qml")
self._dialog = application.createQmlComponent(path, {"manager": self})
if not self._dialog:
Logger.log("e", "Unable to create settings guide dialogue.")
def __matchVersion():
cura_version = Application.getInstance().getVersion()
if cura_version == "master":
Logger.log("d", "Running Cura from source. Skipping version check")
return True
if cura_version == "Arachne_engine_alpha":
Logger.log(
"d", "Running Cura Arachne_engine_alpha. Skipping version check")
return True
cura_version = Version(cura_version)
cura_version = Version([cura_version.getMajor(), cura_version.getMinor()])
# Get version information from plugin.json
plugin_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"plugin.json")
try:
with open(plugin_file_path, encoding="utf-8") as plugin_file:
plugin_info = json.load(plugin_file)
minimum_cura_version = Version(plugin_info["minimum_cura_version"])
maximum_cura_version = Version(plugin_info["maximum_cura_version"])
except Exception as e:
Logger.log(
"w", "Could not get version information for the plugin: " + str(e))
return False
if cura_version >= minimum_cura_version and cura_version <= maximum_cura_version:
return True
else:
Logger.log(
"d",
"This version of MKS WiFi Plugin is not compatible with current version of Cura. Please check for an update."
)
return False
def __initializeStoragePaths(cls) -> None:
Logger.log("d", "Initializing storage paths")
# use nested structure: <app-name>/<version>/...
if cls.ApplicationVersion == "master" or cls.ApplicationVersion == "unknown":
storage_dir_name = os.path.join(cls.ApplicationIdentifier,
cls.ApplicationVersion)
else:
version = Version(cls.ApplicationVersion)
storage_dir_name = os.path.join(
cls.ApplicationIdentifier,
"%s.%s" % (version.getMajor(), version.getMinor()))
# config is saved in "<CONFIG_ROOT>/<storage_dir_name>"
cls.__config_storage_path = os.path.join(
Resources._getConfigStorageRootPath(), storage_dir_name)
Logger.log("d", "Config storage path is %s", cls.__config_storage_path)
# data is saved in
# - on Linux: "<DATA_ROOT>/<storage_dir_name>"
# - on other: "<CONFIG_DIR>" (in the config directory)
data_root_path = Resources._getDataStorageRootPath()
cls.__data_storage_path = cls.__config_storage_path if data_root_path is None else \
os.path.join(data_root_path, storage_dir_name)
Logger.log("d", "Data storage path is %s", cls.__data_storage_path)
# cache is saved in
# - on Linux: "<CACHE_DIR>/<storage_dir_name>"
# - on Windows: "<CACHE_DIR>/<storage_dir_name>/cache"
# - on Mac: "<CONFIG_DIR>/cache" (in the config directory)
cache_root_path = Resources._getCacheStorageRootPath()
if cache_root_path is None:
cls.__cache_storage_path = os.path.join(cls.__config_storage_path,
"cache")
else:
cls.__cache_storage_path = os.path.join(cache_root_path,
storage_dir_name)
if Platform.isWindows():
cls.__cache_storage_path = os.path.join(
cls.__cache_storage_path, "cache")
Logger.log("d", "Cache storage path is %s", cls.__cache_storage_path)
if not os.path.exists(cls.__config_storage_path) or not os.path.exists(
cls.__data_storage_path):
cls._copyLatestDirsIfPresent()
if not os.path.exists(cls.__cache_storage_path):
try:
os.makedirs(cls.__cache_storage_path, exist_ok=True)
except EnvironmentError as e:
Logger.error(f"Unable to create cache path: {e}")
cls.__paths.insert(0, cls.__data_storage_path)
def isPackageCompatible(self, package_api_version: UMVersion) -> bool:
"""
Check whether an API version is compatible with the application's API
version.
:param package_api_version: The API version to check.
:return: ``True`` if packages with this API version are compatible, or
``False`` if they are not.
"""
app_api_version = self._application.getAPIVersion()
if app_api_version.getMajor() != package_api_version.getMajor():
return False
# minor versions are backwards compatible
if app_api_version.getMinor() < package_api_version.getMinor():
return False
return True
def __initializeStoragePaths(cls):
Logger.log("d", "Initializing storage paths")
# use nested structure: <app-name>/<version>/...
if cls.ApplicationVersion == "master" or cls.ApplicationVersion == "unknown":
storage_dir_name = os.path.join(cls.ApplicationIdentifier, cls.ApplicationVersion)
else:
from UM.Version import Version
version = Version(cls.ApplicationVersion)
storage_dir_name = os.path.join(cls.ApplicationIdentifier, "%s.%s" % (version.getMajor(), version.getMinor()))
# config is saved in "<CONFIG_ROOT>/<storage_dir_name>"
cls.__config_storage_path = os.path.join(Resources._getConfigStorageRootPath(), storage_dir_name)
Logger.log("d", "Config storage path is %s", cls.__config_storage_path)
# data is saved in
# - on Linux: "<DATA_ROOT>/<storage_dir_name>"
# - on other: "<CONFIG_DIR>" (in the config directory)
data_root_path = Resources._getDataStorageRootPath()
cls.__data_storage_path = cls.__config_storage_path if data_root_path is None else \
os.path.join(data_root_path, storage_dir_name)
Logger.log("d", "Data storage path is %s", cls.__data_storage_path)
# cache is saved in
# - on Linux: "<CACHE_DIR>/<storage_dir_name>"
# - on Windows: "<CACHE_DIR>/<storage_dir_name>/cache"
# - on Mac: "<CONFIG_DIR>/cache" (in the config directory)
cache_root_path = Resources._getCacheStorageRootPath()
if cache_root_path is None:
cls.__cache_storage_path = os.path.join(cls.__config_storage_path, "cache")
else:
cls.__cache_storage_path = os.path.join(cache_root_path, storage_dir_name)
if Platform.isWindows():
cls.__cache_storage_path = os.path.join(cls.__cache_storage_path, "cache")
Logger.log("d", "Cache storage path is %s", cls.__cache_storage_path)
if not os.path.exists(cls.__config_storage_path):
cls._copyLatestDirsIfPresent()
cls.__paths.insert(0, cls.__data_storage_path)
def __matchVersion():
cura_version = Application.getInstance().getVersion()
if cura_version == "master":
Logger.log("d", "Running Cura from source, ignoring version of the plugin")
return True
cura_version = Version(cura_version)
cura_version = Version([cura_version.getMajor(), cura_version.getMinor()])
# Get version information from plugin.json
plugin_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugin.json")
try:
with open(plugin_file_path) as plugin_file:
plugin_info = json.load(plugin_file)
minimum_cura_version = Version(plugin_info["minimum_cura_version"])
maximum_cura_version = Version(plugin_info["maximum_cura_version"])
except:
Logger.log("w", "Could not get version information for the plugin")
return False
if cura_version >= minimum_cura_version and cura_version <= maximum_cura_version:
return True
else:
Logger.log("d", "This version of the plugin is not compatible with this version of Cura. Please check for an update.")
return False
def check_version_equals(first_version: Version, second_version: Version):
assert first_version == second_version
assert first_version.getMajor() == second_version.getMajor()
assert first_version.getMinor() == second_version.getMinor()
assert first_version.getRevision() == second_version.getRevision()
def check_version_equals(first_version: Version, second_version: Version):
assert first_version == second_version
assert first_version.getMajor() == second_version.getMajor()
assert first_version.getMinor() == second_version.getMinor()
assert first_version.getRevision() == second_version.getRevision()