def emit(self, *args, **kwargs):
try:
if self.__type == Signal.Queued:
Signal._app.functionEvent(CallFunctionEvent(self.emit, args, kwargs))
return
if self.__type == Signal.Auto:
if threading.current_thread() is not Signal._app.getMainThread():
Signal._app.functionEvent(CallFunctionEvent(self.emit, args, kwargs))
return
except AttributeError: # If Signal._app is not set
return
# Quickly make some private references to the collections we need to process.
# Although the these fields are always safe to use read and use with regards to threading,
# we want to operate on a consistent snapshot of the whole set of fields.
with self.__lock:
functions = self.__functions
methods = self.__methods
signals = self.__signals
# Call handler functions
for func in functions:
func(*args, **kwargs)
# Call handler methods
for dest, func in methods:
func(dest, *args, **kwargs)
# Emit connected signals
for signal in signals:
signal.emit(*args, **kwargs)
def emit(self, *args: Any, **kwargs: Any) -> None:
# Check to see if we need to postpone emits
if self._postpone_emit:
if threading.current_thread() != self._postpone_thread:
Logger.log("w", "Tried to emit signal from thread %s while emits are being postponed by %s. Traceback:", threading.current_thread(), self._postpone_thread)
tb = traceback.format_stack()
for line in tb:
Logger.log("w", line)
if self._compress_postpone:
# If emits should be compressed, we only emit the last emit that was called
self._postponed_emits = (args, kwargs)
else:
# If emits should not be compressed, we catch all calls to emit and put them in a list to be called later.
if not self._postponed_emits:
self._postponed_emits = []
self._postponed_emits.append((args, kwargs))
return
try:
if self.__type == Signal.Queued:
Signal._app.functionEvent(CallFunctionEvent(self.__performEmit, args, kwargs))
return
if self.__type == Signal.Auto:
if threading.current_thread() is not Signal._app.getMainThread():
Signal._app.functionEvent(CallFunctionEvent(self.__performEmit, args, kwargs))
return
except AttributeError: # If Signal._app is not set
return
self.__performEmit(*args, **kwargs)
def emit(self, *args, **kargs):
try:
if self.__type == Signal.Queued:
Signal._app.functionEvent(CallFunctionEvent(self.emit, args, kargs))
return
if self.__type == Signal.Auto:
if threading.current_thread() is not Signal._app.getMainThread():
Signal._app.functionEvent(CallFunctionEvent(self.emit, args, kargs))
return
except AttributeError: # If Signal._app is not set
return
self.__emitting = True
# Call handler functions
for func in self.__functions:
func(*args, **kargs)
# Call handler methods
for dest, funcs in self.__methods.items():
for func in funcs:
func(dest, *args, **kargs)
# Emit connected signals
for signal in self.__signals:
signal.emit(*args, **kargs)
self.__emitting = False
for connector in self.__connect_queue:
self.connect(connector)
self.__connect_queue.clear()
for connector in self.__disconnect_queue:
self.disconnect(connector)
self.__connect_queue.clear()
def emit(self, *args, **kwargs):
try:
if self.__type == Signal.Queued:
Signal._app.functionEvent(
CallFunctionEvent(self.__performEmit, args, kwargs))
return
if self.__type == Signal.Auto:
if threading.current_thread() is not Signal._app.getMainThread(
):
Signal._app.functionEvent(
CallFunctionEvent(self.__performEmit, args, kwargs))
return
except AttributeError: # If Signal._app is not set
return
self.__performEmit(*args, **kwargs)
def emit(self, *args: Any, **kwargs: Any) -> None:
"""Emit the signal which indirectly calls all of the connected slots.
:param args: The positional arguments to pass along.
:param kwargs: The keyword arguments to pass along.
:note If the Signal type is Queued and this is not called from the application thread
the call will be posted as an event to the application main thread, which means the
function will be called on the next application event loop tick.
"""
# Check to see if we need to postpone emits
if self._postpone_emit:
if threading.current_thread() != self._postpone_thread:
Logger.log(
"w",
"Tried to emit signal from thread %s while emits are being postponed by %s. Traceback:",
threading.current_thread(), self._postpone_thread)
tb = traceback.format_stack()
for line in tb:
Logger.log("w", line)
if self._compress_postpone == CompressTechnique.CompressSingle:
# If emits should be compressed, we only emit the last emit that was called
self._postponed_emits = (args, kwargs)
else:
# If emits should not be compressed or compressed per parameter value, we catch all calls to emit and put them in a list to be called later.
if not self._postponed_emits:
self._postponed_emits = []
self._postponed_emits.append((args, kwargs))
return
try:
if self.__type == Signal.Queued:
Signal._app.functionEvent(
CallFunctionEvent(self.__performEmit, args, kwargs))
return
if self.__type == Signal.Auto:
if threading.current_thread() is not Signal._app.getMainThread(
):
Signal._app.functionEvent(
CallFunctionEvent(self.__performEmit, args, kwargs))
return
except AttributeError: # If Signal._app is not set
return
self.__performEmit(*args, **kwargs)
def openDocumentation(self) -> None:
# Starting a web browser from a signal handler connected to a menu will crash on windows.
# So instead, defer the call to the next run of the event loop, since that does work.
# Note that weirdly enough, only signal handlers that open a web browser fail like that.
event = CallFunctionEvent(
self._openUrl, [QUrl("http://ultimaker.com/en/support/software")],
{})
cura.CuraApplication.CuraApplication.getInstance().functionEvent(event)
def openDocumentation(self):
# Starting a web browser from a signal handler connected to a menu will crash on windows.
# So instead, defer the call to the next run of the event loop, since that does work.
# Note that weirdly enough, only signal handlers that open a web browser fail like that.
event = CallFunctionEvent(self._openUrl, [
QUrl("http://www.bcn3dtechnologies.com/en/3d-printer/bcn3d-cura/")
], {})
Application.getInstance().functionEvent(event)
def requestWriteToDevice(self, device_id, file_name):
# On Windows, calling requestWrite() on LocalFileOutputDevice crashes when called from a signal
# handler attached to a QML MenuItem. So instead, defer the call to the next run of the event
# loop, since that does work.
event = CallFunctionEvent(self._writeToDevice, [
Application.getInstance().getController().getScene().getRoot(),
device_id, file_name
], {})
Application.getInstance().functionEvent(event)
def openDocumentation(self) -> None:
# Starting a web browser from a signal handler connected to a menu will crash on windows.
# So instead, defer the call to the next run of the event loop, since that does work.
# Note that weirdly enough, only signal handlers that open a web browser fail like that.
event = CallFunctionEvent(
self._openUrl, [QUrl("https://stereotech.org/manuals/steslicer")],
{})
steslicer.SteSlicerApplication.SteSlicerApplication.getInstance(
).functionEvent(event)
def __handleEmitIndirect(self, *args, **kwargs) -> None:
# Handle any indirect emits of signals (eg; type is "Auto" or "Queued"
try:
if self.__type == Signal.Queued:
Signal._app.functionEvent(
CallFunctionEvent(self.__performEmitIndirect, args,
kwargs))
if self.__type == Signal.Auto:
if threading.current_thread() is not Signal._app.getMainThread(
):
Signal._app.functionEvent(
CallFunctionEvent(self.__performEmitIndirect, args,
kwargs))
else:
# Signal is emitted from the main thread, so call it directly!
self.__performEmit(*args, **kwargs)
except AttributeError: # If Signal._app is not set
pass
def openDocumentation(self) -> None:
# Starting a web browser from a signal handler connected to a menu will crash on windows.
# So instead, defer the call to the next run of the event loop, since that does work.
# Note that weirdly enough, only signal handlers that open a web browser fail like that.
event = CallFunctionEvent(self._openUrl, [
QUrl(
"https://ultimaker.com/en/resources/manuals/software?utm_source=cura&utm_medium=software&utm_campaign=dropdown-documentation"
)
], {})
cura.CuraApplication.CuraApplication.getInstance().functionEvent(event)
def createInstance(self, name, definition_id):
definition = self._manager.findMachineDefinition(definition_id)
instance = MachineInstance(self._manager, name = name, definition = definition)
self._manager.addMachineInstance(instance)
# Workaround for an issue on OSX where directly calling setActiveMachineInstance would
# crash in the QML garbage collector.
event = CallFunctionEvent(self._manager.setActiveMachineInstance, [instance], {})
Application.getInstance().functionEvent(event)
def callLater(self, func: Callable[..., Any], *args, **kwargs) -> None:
"""Call a function the next time the event loop runs.
You can't get the result of this function directly. It won't block.
:param func: The function to call.
:param args: The positional arguments to pass to the function.
:param kwargs: The keyword arguments to pass to the function.
"""
event = CallFunctionEvent(func, args, kwargs)
self.functionEvent(event)
def requestWriteSelectionToDevice(self, device_id, file_name):
if not Selection.hasSelection():
return
# On Windows, calling requestWrite() on LocalFileOutputDevice crashes when called from a signal
# handler attached to a QML MenuItem. So instead, defer the call to the next run of the event
# loop, since that does work.
event = CallFunctionEvent(
self._writeToDevice,
[Selection.getSelectedObject(0), device_id, file_name], {})
Application.getInstance().functionEvent(event)
def openBugReportPage(self):
event = CallFunctionEvent(
self._openUrl, [QUrl("http://github.com/BCN3D/Cura/issues")], {})
Application.getInstance().functionEvent(event)
def openBugReportPage(self) -> None:
event = CallFunctionEvent(self._openUrl, [
QUrl("https://gitlab.com/stereotech/steslicer/ste-slicer/issues")
], {})
steslicer.SteSlicerApplication.SteSlicerApplication.getInstance(
).functionEvent(event)
def openWebsitePage(self):
event = CallFunctionEvent(self._openUrl, [QUrl("http://intamsys.com")],
{})
Application.getInstance().functionEvent(event)
def callLater(self, function, *args, **kwargs):
event = CallFunctionEvent(function, args, kwargs)
self.functionEvent(event)
def openLink(self, link):
event = CallFunctionEvent(self._openUrl, [QUrl(link)], {})
Application.getInstance().functionEvent(event)
def openBugReportPage(self):
event = CallFunctionEvent(
self._openUrl,
[QUrl("https://code.alephobjects.com/project/board/10/")], {})
Application.getInstance().functionEvent(event)
def openBugReportPage(self) -> None:
event = CallFunctionEvent(self._openUrl, [QUrl("https://github.com/Ultimaker/Cura/issues")], {})
cura.CuraApplication.CuraApplication.getInstance().functionEvent(event)
def openPartsPage(self):
event = CallFunctionEvent(
self._openUrl, [QUrl("https://www.lulzbot.com/store/parts")], {})
Application.getInstance().functionEvent(event)
def callLater(self, func: Callable[..., Any], *args, **kwargs) -> None:
event = CallFunctionEvent(func, args, kwargs)
self.functionEvent(event)
def openMerchandisePage(self):
event = CallFunctionEvent(
self._openUrl, [QUrl("https://www.lulzbot.com/store/merchandise")],
{})
Application.getInstance().functionEvent(event)
