def renameMaterial(self, message: QDBusMessage):
machine_manager = Application.getInstance().getMachineManager()
material_id = message.arguments()[0]
new_material_name = message.arguments()[1]
machine_manager.renameMaterial(material_id, new_material_name)
def __init__(self, msg: QDBusMessage) -> None:
assert msg.type() == QDBusMessage.ErrorMessage
self.error = msg.errorName()
self.error_message = msg.errorMessage()
self.is_fatal = self.error not in self._NON_FATAL_ERRORS
text = f"{self.error}: {self.error_message}"
super().__init__(text)
def _verify_message(
self,
msg: QDBusMessage,
expected_signature: str,
expected_type: QDBusMessage.MessageType,
) -> None:
"""Check the signature/type of a received message.
Raises DBusError if the signature doesn't match.
"""
assert expected_type not in [
QDBusMessage.ErrorMessage,
QDBusMessage.InvalidMessage,
], expected_type
if msg.type() == QDBusMessage.ErrorMessage:
raise DBusError(msg)
signature = msg.signature()
if signature != expected_signature:
raise Error(
f"Got a message with signature {signature} but expected "
f"{expected_signature} (args: {msg.arguments()})")
typ = msg.type()
if typ != expected_type:
type_str = debug.qenum_key(QDBusMessage.MessageType, typ)
expected_type_str = debug.qenum_key(QDBusMessage.MessageType,
expected_type)
raise Error(
f"Got a message of type {type_str} but expected {expected_type_str}"
f"(args: {msg.arguments()})")
def duplicateMaterial(self, message: QDBusMessage):
from cura.Settings.ContainerManager import ContainerManager
container_manager = ContainerManager.getInstance()
base_material_id = message.arguments()[0] # material to duplicate from
new_id = message.arguments()[1] # (preferred) duplicated material ID
container_manager.duplicateMaterial(base_material_id, new_id)
def setQualityProfile(self, message: QDBusMessage):
qualityProfileName = message.arguments()[0]
machine_manager = Application.getInstance().getMachineManager()
machine_manager.setActiveQuality(qualityProfileName)
reply = message.createReply()
self._session_bus.send(reply)
def hasMachine(self, message: QDBusMessage):
machine_name = message.arguments()[0]
machine_manager = Application.getInstance().getMachineManager()
result = machine_manager.hasMachine(machine_name)
reply = message.createReply()
reply.setArguments([result])
self._session_bus.send(reply)
def hasMaterial(self, message: QDBusMessage):
machine_manager = Application.getInstance().getMachineManager()
material_id = message.arguments()[0]
reply = message.createReply()
reply.setArguments([machine_manager.hasMaterial(material_id)])
self._session_bus.send(reply)
def createMaterial(self, message: QDBusMessage):
from cura.Settings.ContainerManager import ContainerManager
container_manager = ContainerManager.getInstance()
new_id = message.arguments()[0]
new_name = message.arguments()[1]
container_manager.createMaterial(new_id=new_id, new_name=new_name)
def handle_dbus_add(self, msg: QDBusMessage):
if 'org.freedesktop.UDisks2.Drive' in msg.arguments()[1]:
vendor = msg.arguments(
)[1]['org.freedesktop.UDisks2.Drive']['Vendor']
model = msg.arguments(
)[1]['org.freedesktop.UDisks2.Drive']['Model']
# serial = msg.arguments()[1]['org.freedesktop.UDisks2.Drive']['Serial']
print(f"Dbus detected new device: {vendor} {model}")
self.drives_list.refresh()
def exportMaterial(self, message: QDBusMessage):
material_id = message.arguments()[0]
material_file_path = message.arguments()[1]
from cura.Settings.ContainerManager import ContainerManager
container_manager = ContainerManager.getInstance()
container_manager.exportContainer(
material_id,
container_manager.getContainerNameFilters("material")[0],
material_file_path)
def GetCapabilities(self, message: QDBusMessage) -> List[str]:
assert not message.signature()
assert not message.arguments()
assert message.type() == QDBusMessage.MethodCallMessage
capabilities = ["actions", "x-kde-origin-name"]
if self.supports_body_markup:
capabilities.append("body-markup")
return capabilities
def Notify(self, dbus_message: QDBusMessage) -> int:
assert dbus_message.signature() == 'susssasa{sv}i'
assert dbus_message.type() == QDBusMessage.MethodCallMessage
message = self._parse_notify_args(*dbus_message.arguments())
if message.replaces_id == 0:
message_id = next(self._message_id_gen)
else:
message_id = message.replaces_id
self.messages[message_id] = message
self.last_id = message_id
return message_id
def saveFile(self, message: QDBusMessage):
if not message.arguments() or len(message.arguments()) > 2:
return
file_path = message.arguments()[0]
mime_type = "text/x-gcode"
if len(message.arguments()) == 2:
mime_type = message.arguments()[1]
nodes = Application.getInstance().getController().getScene().getRoot()
output_device = Application.getInstance().getOutputDeviceManager(
).getOutputDevice("local_file")
output_device.requestWrite(nodes,
file_path, [mime_type],
silent=True,
preferred_mimetype=mime_type)
def getActiveMaterial(self, message: QDBusMessage):
machine_manager = Application.getInstance().getMachineManager()
reply = message.createReply()
reply.setArguments(
[machine_manager.getActiveMaterial().serializeMetaData()])
self._session_bus.send(reply)
def callMethod(cls,
method_name: str,
signature: str,
*args,
service_path: str = DefaultServicePath,
object_path: str = DefaultObjectPath,
interface: str = DefaultInterface) -> Any:
cls.__ensureDBusSetup()
assert cls.__connection is not None
if cls.__use_qt:
message = QDBusMessage.createMethodCall(service_path, object_path,
interface, method_name)
message.setArguments(args)
result = QDBusReply(cls.__connection.call(message))
if result.isValid():
return result.value()
else:
log.warning("Did not receive a valid reply for method call %s",
method_name)
log.warning(result.error().message())
return None
else:
return cls.__connection.call_blocking(service_path, object_path,
interface, method_name,
signature, args)
def test3():
self._state["recordingExposureNs"] = int(8.5e8)
signal = QDBusMessage.createSignal(
'/', 'com.krontech.chronos.control.mock',
'recordingExposureNs')
signal << self._state["recordingExposureNs"]
QDBusConnection.systemBus().send(signal)
def setIconName(self, value):
self._iconName = value
msg = QDBusMessage.createSignal("/StatusNotifierItem",
"org.kde.StatusNotifierItem",
"NewIcon")
msg.setArguments([])
self.__sessionService.sessionBus.send(msg)
def getMaterial(self, message: QDBusMessage):
from UM.Settings.ContainerRegistry import ContainerRegistry
container_registry = ContainerRegistry.getInstance()
material_id = message.arguments()[0]
material = container_registry.findInstanceContainers(id=material_id,
type="material")
material_data = None
if material:
material = material[0]
material_data = material.serializeMetaData()
reply = message.createReply()
reply.setArguments([material_data])
self._session_bus.send(reply)
def _on_interfaces_added(self, msg: QDBusMessage):
objpath, interfaces = msg.arguments()
print("added", objpath)
for interface, properties in interfaces.items():
print(" ", interface)
for name, value in properties.items():
print(" ", name, "=", value)
def _on_interfaces_added(self, msg: QDBusMessage):
objpath, interfaces = msg.arguments()
print("added", objpath)
for interface, properties in interfaces.items():
print(" ", interface)
for name, value in properties.items():
print(" ", name, "=", value)
def _updateLayout(self):
self._revision += 1
msg = QDBusMessage.createSignal("/MenuBar", "com.canonical.dbusmenu", "LayoutUpdated")
msg.setArguments([
QDBusArgument(self._revision, QMetaType.UInt),
QDBusArgument(DBusMenuAction.Root.value, QMetaType.Int),
])
self.__sessionService.sessionBus.send(msg)
def call_cura(method, *args):
dbus_service = "nl.ultimaker.cura"
dbus_object = "/Application"
dbus_interface = "nl.ultimaker.cura.Application"
message = QDBusMessage.createMethodCall(dbus_service, dbus_object,
dbus_interface, method)
message.setArguments(args)
QDBusConnection.sessionBus().call(message)
def setProgress(self, value: float, visible: bool = True):
signal = QDBusMessage.createSignal(
'/com/canonical/unity/launcherentry/337963624',
'com.canonical.Unity.LauncherEntry', 'Update')
message = signal << self._desktopfile << {
'progress-visible': visible,
'progress': value
}
self._sessionbus.send(message)
def setIconName(self, value):
self._iconName = value
msg = QDBusMessage.createSignal(
"/StatusNotifierItem",
"org.kde.StatusNotifierItem",
"NewIcon"
)
msg.setArguments([])
self.__sessionService.sessionBus.send(msg)
def update(self, progress, visible=True):
self._progress = progress
self._visible = visible
# Automatic forwarding of Qt signals does not work in this case
# since Qt cannot handle the complex "a{sv}" type.
# Create the signal message manually.
message = QDBusMessage.createSignal(self._path, DBUS_INTERFACE, 'Update')
message.setArguments([self._app_uri, self.current_progress])
self._bus.send(message)
def getActiveExtruder(self, message: QDBusMessage):
extruder_manager = Application.getInstance().getExtruderManager()
active_extruder = extruder_manager.getActiveExtruderStack()
extruder_data = active_extruder.serializeMetaData()
reply = message.createReply()
reply.setArguments([extruder_data])
self._session_bus.send(reply)
def setProgress(self, value: float, visible: bool=True) -> bool:
if sys.platform.startswith('linux') and self._sessionbus.isConnected():
signal = QDBusMessage.createSignal('/com/canonical/unity/launcherentry/337963624',
'com.canonical.Unity.LauncherEntry', 'Update')
message = signal << self._desktopfile << {'progress-visible': visible, 'progress': value}
return self._sessionbus.send(message)
elif sys.platform == 'win32' and TaskbarProgress.isValidWinVer():
self.parent.win_taskbar_button.progress().setValue(int(value * 100))
return True
def action(self, notification_id: int, name: str) -> None:
"""Sends an action notification for the given ID."""
message = QDBusMessage.createSignal(
notification.DBusNotificationAdapter.PATH,
notification.DBusNotificationAdapter.INTERFACE, "ActionInvoked")
message.setArguments([notification._as_uint32(notification_id), name])
if not self._bus.send(message):
raise OSError("Could not send action notification")
def _updateLayout(self):
self._revision += 1
msg = QDBusMessage.createSignal("/MenuBar", "com.canonical.dbusmenu",
"LayoutUpdated")
msg.setArguments([
QDBusArgument(self._revision, QMetaType.UInt),
QDBusArgument(DBusMenuAction.Root.value, QMetaType.Int),
])
self.__sessionService.sessionBus.send(msg)
def set(self, data):
# Check all errors first to avoid partially applying an update.
for key, value in data.items():
if key not in self._state:
# return self.sendErrorReply('unknownValue', f"The value '{key}' is not known. Valid keys are: {self._state.keys()}")
cameraControlAPI.send(
QDBusMessage.createErrorReply(
'unknownValue',
f"The value '{key}' is not known. Valid keys are: {self._state.keys()}"
))
if not isinstance(value, type(self._state[key])):
return cameraControlAPI.send(
QDBusMessage.createErrorReply(
'wrongType',
f"Can not set '{key}' to {value}. (Previously {self._state[key]}.) Expected {type(self._state[key])}, got {type(value)}."
))
for key, value in data.items():
self._state[key] = value
def _handle_close(self, msg: QDBusMessage) -> None:
"""Handle NotificationClosed from DBus."""
try:
self._verify_message(msg, "uu", QDBusMessage.SignalMessage)
except Error:
if not self._quirks.wrong_closes_type:
raise
self._verify_message(msg, "ui", QDBusMessage.SignalMessage)
notification_id, _close_reason = msg.arguments()
self.close_id.emit(notification_id)
def getActiveQuality(self, message: QDBusMessage):
machine_manager = Application.getInstance().getMachineManager()
quality = machine_manager.activeMachine.quality
data = quality.getMetaData().copy()
data["id"] = quality.getId()
data["name"] = quality.getName()
reply = message.createReply()
reply.setArguments([json.dumps(data)])
self._session_bus.send(reply)
def getQualityProfiles(self, message: QDBusMessage):
available_quality_profiles = ProfilesModel.getInstance().items
qualities = []
for quality_profile in available_quality_profiles:
qualities.append({
"name": quality_profile["name"],
"id": quality_profile["id"]
})
reply = message.createReply()
reply.setArguments(qualities)
self._session_bus.send(reply)
def sendRequest(req, *args):
global BUS
LOGGER.debug('sending request %r%r', req, args)
method_args = [req]
method_args.extend(args)
msg = QDBusMessage.createMethodCall('re.indigo.eye', '/', 're.indigo.eye', 'request')
msg.setArguments(method_args)
BUS = QDBusConnection.sessionBus()
reply = BUS.call(msg)
if reply.type() == QDBusMessage.ErrorMessage:
raise ValueError(reply.errorMessage())
return list(reply.arguments())
def sendClickedSlot(self):
msg = QDBusMessage.createSignal('/', 'org.example.chat', 'message')
msg << self.m_nickname << self.messageLineEdit.text()
QDBusConnection.sessionBus().send(msg)
self.messageLineEdit.setText('')
def invokeItem(self, id):
msg = QDBusMessage.createSignal('/com/deepin/menu', 'com.deepin.menu.Menu', 'ItemInvoked')
msg << id
QDBusConnection.sessionBus().send(msg)
def _on_interfaces_removed(self, msg: QDBusMessage):
print("removed", msg.arguments())
