def present(self, newNotification):
if self.notification:
self.notification.close()
sip.delete(self.notification)
self.notification = None
self.notification = newNotification
self.m_title.setText(f"<b>{self.notification.title()}</b>")
self.m_message.setText(self.notification.message())
self.m_icon.setPixmap(
QPixmap.fromImage(self.notification.icon()).scaledToHeight(
self.m_icon.height()))
self.show()
self.notification.show()
self.notification.closed.connect(self.onClosed)
QTimer.singleShot(
10000, lambda: self.onClosed()
if self.notification is not None else None)
# position our popup in the right corner of its parent widget
self.move(self.parentWidget().mapToGlobal(
self.parentWidget().rect().bottomRight() -
QPoint(self.width() + 10,
self.height() + 10)))
def main():
import sys
QCoreApplication.setOrganizationName("QtExamples")
QCoreApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
# QtWebEngine::initialize()
if QT_NO_WIDGETS:
app = QApplication(sys.argv)
else:
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
server = Server(engine)
engine.load(QUrl("qrc:/main.qml"))
QTimer.singleShot(0, server.run)
proxy = QNetworkProxy()
proxy.setType(QNetworkProxy.HttpProxy)
proxy.setHostName("localhost")
proxy.setPort(5555)
QNetworkProxy.setApplicationProxy(proxy)
sys.exit(app.exec_())
def __init__(self, *args):
super(StatusWidget, self).__init__(*args)
self._status = None
self._blocking = False
self._timer = QTimer(self)
self.setObjectName('StatusWidget')
self.setFrameShape(QFrame.NoFrame)
self.setFixedHeight(19)
self.setMinimumWidth(5)
self._label = label.BaseLabel('', parent=self)
self._label.setStyleSheet('background-color: transparent;')
self._label.setCursor(Qt.IBeamCursor)
self._label.setTextInteractionFlags(Qt.TextSelectableByMouse)
self._label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.label_image = label.BaseLabel(parent=self)
self.label_image.setMaximumSize(QSize(17, 17))
self.label_image.hide()
self.main_layout = QHBoxLayout(self)
self.main_layout.setContentsMargins(1, 0, 0, 0)
self.main_layout.addWidget(self.label_image)
self.main_layout.addWidget(self._label)
self.setLayout(self.main_layout)
self._timer.timeout.connect(self._reset)
# Force set to initialize default status Qt property
self.status = ''
def __init__(self, parent=None):
super(ToolTipWidget, self).__init__(parent)
self._layout = None
self._content = None
self._content_parent = None
self._hide_timer = QTimer(self)
self._init()
def _doit(factory):
try:
app = QApplication([])
except RuntimeError:
app = QCoreApplication.instance()
main_window = factory()
if getattr(sys, '_called_from_test', False) and is_windows_platform():
QTimer.singleShot(500, app, Slot('quit()'))
main_window.show()
app.exec_()
def __init__(self):
font = QFont()
font.setPointSize(8)
font.setFamily("Calibri")
self.setFont(font)
self._hover = False
self._glow_index = 0
self._anim_timer = QTimer()
self._anim_timer.timeout.connect(self._animate_glow)
def _doit(factory):
try:
app = QApplication([])
except RuntimeError:
app = QCoreApplication.instance()
main_window = factory()
if getattr(sys, '_called_from_test', False) and is_windows_platform():
QTimer.singleShot(500, app, Slot('quit()'))
main_window.show()
app.exec_()
def __init__(self, name, graph):
super(retriggerableDelay, self).__init__(name, graph)
self.inp0 = self.addInputPin('in0',
DataTypes.Exec,
self.compute,
hideLabel=True)
self.delay = self.addInputPin('Delay(s)', DataTypes.Float)
self.delay.setDefaultValue(0.2)
self.out0 = self.addOutputPin('out0', DataTypes.Exec, hideLabel=True)
self.process = False
self.timer = QTimer()
self.timer.timeout.connect(self.callAndReset)
def __init__(self, name):
super(timer, self).__init__(name)
self.out = self.createOutputPin("OUT", 'ExecPin')
self.beginPin = self.createInputPin("Begin", 'ExecPin', None,
self.start)
self.stopPin = self.createInputPin("Stop", 'ExecPin', None, self.stop)
self.resetPin = self.createInputPin("Reset", 'ExecPin', None,
self.reset)
self.interval = self.createInputPin("Delta(ms)", 'FloatPin')
self.interval.setDefaultValue(0.2)
self._timer = QTimer()
self._timer.timeout.connect(self.compute)
def mouseReleaseEvent(self, event):
button = event.button()
self.setDown(False)
if not self._double_click_enabled:
self.mouse_single_click_action(button)
return
if self._last_click == self.SINGLE_CLICK:
QTimer.singleShot(self._double_click_interval,
lambda: self.mouse_single_click_action(button))
else:
self.mouseDoubleClickAction(event.button())
def __init__(self, parent: QWidget = None):
super().__init__(parent)
self.setWindowFlags(self.windowFlags()
& ~Qt.WindowContextHelpButtonHint)
self.server = QLocalServer(self)
if not self.server.listen("fortune"):
QMessageBox.critical(
self,
self.tr("Local Fortune Server"),
self.tr("Unable to start the server: %s." %
(self.server.errorString())),
)
QTimer.singleShot(0, self.close)
return
statusLabel = QLabel()
statusLabel.setWordWrap(True)
statusLabel.setText(
self.
tr("The server is running.\nRun the Local Fortune Client example now."
))
self.fortunes = (
self.tr(
"You've been leading a dog's life. Stay off the furniture."),
self.tr("You've got to think about tomorrow."),
self.tr("You will be surprised by a loud noise."),
self.tr("You will feel hungry again in another hour."),
self.tr("You might have mail."),
self.tr("You cannot kill time without injuring eternity."),
self.tr(
"Computers are not intelligent. They only think they are."),
)
quitButton = QPushButton(self.tr("Quit"))
quitButton.setAutoDefault(False)
quitButton.clicked.connect(self.close)
self.server.newConnection.connect(self.sendFortune)
buttonLayout = QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(quitButton)
buttonLayout.addStretch(1)
mainLayout = QVBoxLayout(self)
mainLayout.addWidget(statusLabel)
mainLayout.addLayout(buttonLayout)
self.setWindowTitle(QGuiApplication.applicationDisplayName())
def reset(self):
"""
Stop and reset the current frame to 0
"""
if not self._timer:
self._timer = QTimer(self.parent())
self._timer.setSingleShot(False)
self._timer.timeout.connect(self._on_frame_changed)
if not self._paused:
self._frame = 0
self._timer.stop()
def setup(self, icon_painter, painter, rect):
if self.parent_widget not in self.info:
timer = QTimer()
timer.timeout.connect(self._update)
self.info[self.parent_widget] = [timer, 0, self.step]
timer.start(self.interval)
else:
timer, angle, self.step = self.info[self.parent_widget]
x_center = rect.width() * 0.5
y_center = rect.height() * 0.5
painter.translate(x_center, y_center)
painter.rotate(angle)
painter.translate(-x_center, -y_center)
def _doit(factory):
# for windows these needs to be repeated due to multiprocessing (?)
from Qt.QtWidgets import QApplication
from Qt.QtCore import QCoreApplication
try:
app = QApplication([])
except RuntimeError:
app = QCoreApplication.instance()
main_window = factory()
if getattr(sys, '_called_from_test',
False) and (is_windows_platform() or is_macos_platform()):
QTimer.singleShot(1000, app.quit)
main_window.show()
app.exec_()
def __init__(self, *args):
super(ToastWidget, self).__init__(*args)
self._timer = QTimer(self)
self._timer.setSingleShot(True)
self._timer.timeout.connect(self._on_fade_out)
self._duration = self.DEFAULT_DURATION
self.setMouseTracking(True)
self.setAlignment(Qt.AlignCenter)
self.setAttribute(Qt.WA_TransparentForMouseEvents)
if self.parent():
self.parent().installEventFilter(self)
def __init__(self, parent=None, intermediate=False):
self.parent = parent
self.intermediate = intermediate
self._validate_lock = False
self.timer = QTimer()
self.timer.timeout.connect(self._unlock_validator)
super().__init__(parent)
def readFortune(self):
if self.blockSize == 0:
# Relies on the fact that QDataStream serializes a quint32 into
# sizeof(quint32) bytes
if self.socket.bytesAvailable() < 4: # (int)sizeof(quint32))
return
self.blockSize = self._in.readUInt32()
if self.socket.bytesAvailable() < self.blockSize or self._in.atEnd():
return
nextFortune = ""
nextFortune = self._in.readQString()
if nextFortune == self.currentFortune:
QTimer.singleShot(0, self.requestNewFortune)
return
currentFortune = nextFortune
self.statusLabel.setText(currentFortune)
self.getFortuneButton.setEnabled(True)
def __init__(self, modal=False, parent=None):
super(BalloonDialog, self).__init__(parent)
self._lazy_show_window = QTimer(self)
if modal:
self.setModal(True)
self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint)
self.setAttribute(Qt.WA_DeleteOnClose)
self._lazy_show_window.timeout.connect(self._on_lazy_show_window)
class retriggerableDelay(Node, NodeBase):
def __init__(self, name, graph):
super(retriggerableDelay, self).__init__(name, graph)
self.inp0 = self.addInputPin('in0',
DataTypes.Exec,
self.compute,
hideLabel=True)
self.delay = self.addInputPin('Delay(s)', DataTypes.Float)
self.delay.setDefaultValue(0.2)
self.out0 = self.addOutputPin('out0', DataTypes.Exec, hideLabel=True)
self.process = False
self.timer = QTimer()
self.timer.timeout.connect(self.callAndReset)
def kill(self):
self.timer.stop()
self.timer.timeout.disconnect()
Node.kill(self)
@staticmethod
def pinTypeHints():
return {
'inputs': [DataTypes.Exec, DataTypes.Float],
'outputs': [DataTypes.Exec]
}
@staticmethod
def category():
return 'FlowControl'
@staticmethod
def keywords():
return []
@staticmethod
def description():
return 'Delayed call. With ability to reset.'
def callAndReset(self):
self.out0.call()
self.process = False
self.timer.stop()
def restart(self):
delay = self.delay.getData() * 1000.0
self.timer.stop()
self.timer.start(delay)
def compute(self):
self.restart()
def set_frameless_enabled(self, frameless=False):
"""
Enables/Disables frameless mode or OS system default
:param frameless: bool
"""
from tpDcc.managers import tools
tool_inst = tools.ToolsManager().get_tool_by_plugin_instance(
self._window)
if not tool_inst:
return
offset = QPoint()
if self._window.docked():
rect = self._window.rect()
pos = self._window.mapToGlobal(QPoint(-10, -10))
rect.setWidth(rect.width() + 21)
self._window.close()
else:
rect = self.window().rect()
pos = self.window().pos()
offset = QPoint(3, 15)
self.window().close()
tool_inst._launch(launch_frameless=frameless)
new_tool = tool_inst.latest_tool()
QTimer.singleShot(
0,
lambda: new_tool.window().setGeometry(pos.x() + offset.x(),
pos.y() + offset.y(),
rect.width(), rect.height()))
new_tool.framelessChanged.emit(frameless)
QApplication.processEvents()
return new_tool
def _delay_run(times):
if times <= 0:
return
timer = QTimer()
all_timer.append(timer)
timer.setSingleShot(True)
timer.timeout.connect(_run)
timer.timeout.connect(lambda: _delay_run(times - 1))
timer.start(random.randint(0, 300))
def __init__(self,
title,
position=SliderPanelPositions.RIGHT,
closable=True,
parent=None):
self._title = title
self._position = position
self._closable = closable
self._is_first_close = True
super(SliderPanel, self).__init__(parent)
self.setObjectName('sliderPanel')
self.setWindowFlags(Qt.Popup)
self.setAttribute(Qt.WA_StyledBackground)
self._close_timer = QTimer(self)
self._close_timer.setInterval(300)
self._close_timer.setSingleShot(True)
self._close_timer.timeout.connect(self.close)
self._close_timer.timeout.connect(self.closed.emit)
self._pos_anim = QPropertyAnimation(self)
self._pos_anim.setTargetObject(self)
self._pos_anim.setEasingCurve(QEasingCurve.OutCubic)
self._pos_anim.setDuration(300)
self._pos_anim.setPropertyName(b'pos')
self._opacity_anim = QPropertyAnimation()
self._opacity_anim.setTargetObject(self)
self._opacity_anim.setDuration(300)
self._opacity_anim.setEasingCurve(QEasingCurve.OutCubic)
self._opacity_anim.setPropertyName(b'windowOpacity')
self._opacity_anim.setStartValue(0.0)
self._opacity_anim.setEndValue(1.0)
def __init__(self, text='', input_mode=None, parent=None):
super(BaseLineEdit, self).__init__(text, parent)
self._prefix_widget = None
self._suffix_widget = None
self._size = self.theme_default_size()
self._main_layout = layouts.HorizontalLayout()
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.addStretch()
self.setLayout(self._main_layout)
self.setProperty('history', self.property('text'))
self.setTextMargins(2, 0, 2, 0)
if input_mode == 'float':
self.setValidator(QDoubleValidator())
elif input_mode == 'int':
self.setValidator(QIntValidator())
self._delay_timer = QTimer()
self._delay_timer.setInterval(500)
self._delay_timer.setSingleShot(True)
self._delay_timer.timeout.connect(self._on_delay_text_changed)
def defer(delay, fn, default_delay=1):
"""
Append artificial delay to `func`
This aids in keeping the GUI responsive, but complicates logic
when producing tests. To combat this, the environment variable ensures
that every operation is synchronous.
:param delay: float, Delay multiplier; default 1, 0 means no delay
:param fn: callable, Any callable
:param default_delay: float
"""
delay *= float(default_delay)
if delay > 0:
return QTimer.singleShot(delay, fn)
else:
return fn()
class timer(NodeBase):
def __init__(self, name):
super(timer, self).__init__(name)
self.out = self.createOutputPin("OUT", 'ExecPin')
self.beginPin = self.createInputPin("Begin", 'ExecPin', None,
self.start)
self.stopPin = self.createInputPin("Stop", 'ExecPin', None, self.stop)
self.resetPin = self.createInputPin("Reset", 'ExecPin', None,
self.reset)
self.interval = self.createInputPin("Delta(ms)", 'FloatPin')
self.interval.setDefaultValue(0.2)
self._timer = QTimer()
self._timer.timeout.connect(self.compute)
def kill(self):
self._timer.stop()
self._timer.timeout.disconnect()
NodeBase.kill(self)
@staticmethod
def pinTypeHints():
return {'inputs': ['FloatPin', 'ExecPin'], 'outputs': ['ExecPin']}
def reset(self, *args, **kwargs):
self.stop()
self.start()
def stop(self, *args, **kwargs):
self._timer.stop()
def start(self, *args, **kwargs):
dt = self.interval.getData() * 1000.0
self._timer.start(dt)
@staticmethod
def category():
return 'Utils'
def compute(self, *args, **kwargs):
self.out.call(*args, **kwargs)
def __init__(self, U, plot, length=1, title=None):
super().__init__()
layout = QVBoxLayout()
if title:
title = QLabel('<b>' + title + '</b>')
title.setAlignment(Qt.AlignHCenter)
layout.addWidget(title)
layout.addWidget(plot)
plot.set(U, 0)
if length > 1:
hlayout = QHBoxLayout()
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(0)
self.slider.setMaximum(length - 1)
self.slider.setTickPosition(QSlider.TicksBelow)
hlayout.addWidget(self.slider)
lcd = QLCDNumber(m.ceil(m.log10(length)))
lcd.setDecMode()
lcd.setSegmentStyle(QLCDNumber.Flat)
hlayout.addWidget(lcd)
layout.addLayout(hlayout)
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_play = QAction(self.style().standardIcon(QStyle.SP_MediaPlay), 'Play', self)
self.a_play.setCheckable(True)
self.a_rewind = QAction(self.style().standardIcon(QStyle.SP_MediaSeekBackward), 'Rewind', self)
self.a_toend = QAction(self.style().standardIcon(QStyle.SP_MediaSeekForward), 'End', self)
self.a_step_backward = QAction(self.style().standardIcon(QStyle.SP_MediaSkipBackward),
'Step Back', self)
self.a_step_forward = QAction(self.style().standardIcon(QStyle.SP_MediaSkipForward), 'Step', self)
self.a_loop = QAction(self.style().standardIcon(QStyle.SP_BrowserReload), 'Loop', self)
self.a_loop.setCheckable(True)
toolbar.addAction(self.a_play)
toolbar.addAction(self.a_rewind)
toolbar.addAction(self.a_toend)
toolbar.addAction(self.a_step_backward)
toolbar.addAction(self.a_step_forward)
toolbar.addAction(self.a_loop)
if hasattr(self, 'save'):
self.a_save = QAction(self.style().standardIcon(QStyle.SP_DialogSaveButton), 'Save', self)
toolbar.addAction(self.a_save)
self.a_save.triggered.connect(self.save)
hlayout.addWidget(toolbar)
self.speed = QSlider(Qt.Horizontal)
self.speed.setMinimum(0)
self.speed.setMaximum(100)
hlayout.addWidget(QLabel('Speed:'))
hlayout.addWidget(self.speed)
layout.addLayout(hlayout)
self.timer = QTimer()
self.timer.timeout.connect(self.update_solution)
self.slider.valueChanged.connect(self.slider_changed)
self.slider.valueChanged.connect(lcd.display)
self.speed.valueChanged.connect(self.speed_changed)
self.a_play.toggled.connect(self.toggle_play)
self.a_rewind.triggered.connect(self.rewind)
self.a_toend.triggered.connect(self.to_end)
self.a_step_forward.triggered.connect(self.step_forward)
self.a_step_backward.triggered.connect(self.step_backward)
self.speed.setValue(50)
elif hasattr(self, 'save'):
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_save = QAction(self.style().standardIcon(QStyle.SP_DialogSaveButton), 'Save', self)
toolbar.addAction(self.a_save)
hlayout.addWidget(toolbar)
layout.addLayout(hlayout)
self.a_save.triggered.connect(self.save)
self.setLayout(layout)
self.plot = plot
self.U = U
self.length = length
def compute(self):
if not self.process:
self.process = True
delay = self.delay.getData() * 1000.0
QTimer.singleShot(delay, self.callAndReset)
class PlotMainWindow(QWidget):
"""Base class for plot main windows."""
def __init__(self, U, plot, length=1, title=None):
super().__init__()
layout = QVBoxLayout()
if title:
title = QLabel('<b>' + title + '</b>')
title.setAlignment(Qt.AlignHCenter)
layout.addWidget(title)
layout.addWidget(plot)
plot.set(U, 0)
if length > 1:
hlayout = QHBoxLayout()
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(0)
self.slider.setMaximum(length - 1)
self.slider.setTickPosition(QSlider.TicksBelow)
hlayout.addWidget(self.slider)
lcd = QLCDNumber(m.ceil(m.log10(length)))
lcd.setDecMode()
lcd.setSegmentStyle(QLCDNumber.Flat)
hlayout.addWidget(lcd)
layout.addLayout(hlayout)
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_play = QAction(self.style().standardIcon(QStyle.SP_MediaPlay), 'Play', self)
self.a_play.setCheckable(True)
self.a_rewind = QAction(self.style().standardIcon(QStyle.SP_MediaSeekBackward), 'Rewind', self)
self.a_toend = QAction(self.style().standardIcon(QStyle.SP_MediaSeekForward), 'End', self)
self.a_step_backward = QAction(self.style().standardIcon(QStyle.SP_MediaSkipBackward),
'Step Back', self)
self.a_step_forward = QAction(self.style().standardIcon(QStyle.SP_MediaSkipForward), 'Step', self)
self.a_loop = QAction(self.style().standardIcon(QStyle.SP_BrowserReload), 'Loop', self)
self.a_loop.setCheckable(True)
toolbar.addAction(self.a_play)
toolbar.addAction(self.a_rewind)
toolbar.addAction(self.a_toend)
toolbar.addAction(self.a_step_backward)
toolbar.addAction(self.a_step_forward)
toolbar.addAction(self.a_loop)
if hasattr(self, 'save'):
self.a_save = QAction(self.style().standardIcon(QStyle.SP_DialogSaveButton), 'Save', self)
toolbar.addAction(self.a_save)
self.a_save.triggered.connect(self.save)
hlayout.addWidget(toolbar)
self.speed = QSlider(Qt.Horizontal)
self.speed.setMinimum(0)
self.speed.setMaximum(100)
hlayout.addWidget(QLabel('Speed:'))
hlayout.addWidget(self.speed)
layout.addLayout(hlayout)
self.timer = QTimer()
self.timer.timeout.connect(self.update_solution)
self.slider.valueChanged.connect(self.slider_changed)
self.slider.valueChanged.connect(lcd.display)
self.speed.valueChanged.connect(self.speed_changed)
self.a_play.toggled.connect(self.toggle_play)
self.a_rewind.triggered.connect(self.rewind)
self.a_toend.triggered.connect(self.to_end)
self.a_step_forward.triggered.connect(self.step_forward)
self.a_step_backward.triggered.connect(self.step_backward)
self.speed.setValue(50)
elif hasattr(self, 'save'):
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_save = QAction(self.style().standardIcon(QStyle.SP_DialogSaveButton), 'Save', self)
toolbar.addAction(self.a_save)
hlayout.addWidget(toolbar)
layout.addLayout(hlayout)
self.a_save.triggered.connect(self.save)
self.setLayout(layout)
self.plot = plot
self.U = U
self.length = length
def slider_changed(self, ind):
self.plot.set(self.U, ind)
def speed_changed(self, val):
self.timer.setInterval(val * 20)
def update_solution(self):
ind = self.slider.value() + 1
if ind >= self.length:
if self.a_loop.isChecked():
ind = 0
else:
self.a_play.setChecked(False)
return
self.slider.setValue(ind)
def toggle_play(self, checked):
if checked:
if self.slider.value() + 1 == self.length:
self.slider.setValue(0)
self.timer.start()
else:
self.timer.stop()
def rewind(self):
self.slider.setValue(0)
def to_end(self):
self.a_play.setChecked(False)
self.slider.setValue(self.length - 1)
def step_forward(self):
self.a_play.setChecked(False)
ind = self.slider.value() + 1
if ind == self.length and self.a_loop.isChecked():
ind = 0
if ind < self.length:
self.slider.setValue(ind)
def step_backward(self):
self.a_play.setChecked(False)
ind = self.slider.value() - 1
if ind == -1 and self.a_loop.isChecked():
ind = self.length - 1
if ind >= 0:
self.slider.setValue(ind)
class PlotMainWindow(QWidget):
"""Base class for plot main windows."""
def __init__(self, U, plot, length=1, title=None):
super().__init__()
layout = QVBoxLayout()
if title:
title = QLabel('<b>' + title + '</b>')
title.setAlignment(Qt.AlignHCenter)
layout.addWidget(title)
layout.addWidget(plot)
plot.set(U, 0)
if length > 1:
hlayout = QHBoxLayout()
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(0)
self.slider.setMaximum(length - 1)
self.slider.setTickPosition(QSlider.TicksBelow)
hlayout.addWidget(self.slider)
lcd = QLCDNumber(m.ceil(m.log10(length)))
lcd.setDecMode()
lcd.setSegmentStyle(QLCDNumber.Flat)
hlayout.addWidget(lcd)
layout.addLayout(hlayout)
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_play = QAction(
self.style().standardIcon(QStyle.SP_MediaPlay), 'Play',
self)
self.a_play.setCheckable(True)
self.a_rewind = QAction(
self.style().standardIcon(QStyle.SP_MediaSeekBackward),
'Rewind', self)
self.a_toend = QAction(
self.style().standardIcon(QStyle.SP_MediaSeekForward),
'End', self)
self.a_step_backward = QAction(
self.style().standardIcon(QStyle.SP_MediaSkipBackward),
'Step Back', self)
self.a_step_forward = QAction(
self.style().standardIcon(QStyle.SP_MediaSkipForward),
'Step', self)
self.a_loop = QAction(
self.style().standardIcon(QStyle.SP_BrowserReload), 'Loop',
self)
self.a_loop.setCheckable(True)
toolbar.addAction(self.a_play)
toolbar.addAction(self.a_rewind)
toolbar.addAction(self.a_toend)
toolbar.addAction(self.a_step_backward)
toolbar.addAction(self.a_step_forward)
toolbar.addAction(self.a_loop)
if hasattr(self, 'save'):
self.a_save = QAction(
self.style().standardIcon(QStyle.SP_DialogSaveButton),
'Save', self)
toolbar.addAction(self.a_save)
self.a_save.triggered.connect(self.save)
hlayout.addWidget(toolbar)
self.speed = QSlider(Qt.Horizontal)
self.speed.setMinimum(0)
self.speed.setMaximum(100)
hlayout.addWidget(QLabel('Speed:'))
hlayout.addWidget(self.speed)
layout.addLayout(hlayout)
self.timer = QTimer()
self.timer.timeout.connect(self.update_solution)
self.slider.valueChanged.connect(self.slider_changed)
self.slider.valueChanged.connect(lcd.display)
self.speed.valueChanged.connect(self.speed_changed)
self.a_play.toggled.connect(self.toggle_play)
self.a_rewind.triggered.connect(self.rewind)
self.a_toend.triggered.connect(self.to_end)
self.a_step_forward.triggered.connect(self.step_forward)
self.a_step_backward.triggered.connect(self.step_backward)
self.speed.setValue(50)
elif hasattr(self, 'save'):
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_save = QAction(
self.style().standardIcon(QStyle.SP_DialogSaveButton),
'Save', self)
toolbar.addAction(self.a_save)
hlayout.addWidget(toolbar)
layout.addLayout(hlayout)
self.a_save.triggered.connect(self.save)
self.setLayout(layout)
self.plot = plot
self.U = U
self.length = length
def slider_changed(self, ind):
self.plot.set(self.U, ind)
def speed_changed(self, val):
self.timer.setInterval(val * 20)
def update_solution(self):
ind = self.slider.value() + 1
if ind >= self.length:
if self.a_loop.isChecked():
ind = 0
else:
self.a_play.setChecked(False)
return
self.slider.setValue(ind)
def toggle_play(self, checked):
if checked:
if self.slider.value() + 1 == self.length:
self.slider.setValue(0)
self.timer.start()
else:
self.timer.stop()
def rewind(self):
self.slider.setValue(0)
def to_end(self):
self.a_play.setChecked(False)
self.slider.setValue(self.length - 1)
def step_forward(self):
self.a_play.setChecked(False)
ind = self.slider.value() + 1
if ind == self.length and self.a_loop.isChecked():
ind = 0
if ind < self.length:
self.slider.setValue(ind)
def step_backward(self):
self.a_play.setChecked(False)
ind = self.slider.value() - 1
if ind == -1 and self.a_loop.isChecked():
ind = self.length - 1
if ind >= 0:
self.slider.setValue(ind)
def hideEvent(self, event):
self._remove_widget()
QTimer.singleShot(0, self.hidden.emit)
def __init__(self, U, plot, length=1, title=None):
super().__init__()
layout = QVBoxLayout()
if title:
title = QLabel('<b>' + title + '</b>')
title.setAlignment(Qt.AlignHCenter)
layout.addWidget(title)
layout.addWidget(plot)
plot.set(U, 0)
if length > 1:
hlayout = QHBoxLayout()
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(0)
self.slider.setMaximum(length - 1)
self.slider.setTickPosition(QSlider.TicksBelow)
hlayout.addWidget(self.slider)
lcd = QLCDNumber(m.ceil(m.log10(length)))
lcd.setDecMode()
lcd.setSegmentStyle(QLCDNumber.Flat)
hlayout.addWidget(lcd)
layout.addLayout(hlayout)
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_play = QAction(
self.style().standardIcon(QStyle.SP_MediaPlay), 'Play',
self)
self.a_play.setCheckable(True)
self.a_rewind = QAction(
self.style().standardIcon(QStyle.SP_MediaSeekBackward),
'Rewind', self)
self.a_toend = QAction(
self.style().standardIcon(QStyle.SP_MediaSeekForward),
'End', self)
self.a_step_backward = QAction(
self.style().standardIcon(QStyle.SP_MediaSkipBackward),
'Step Back', self)
self.a_step_forward = QAction(
self.style().standardIcon(QStyle.SP_MediaSkipForward),
'Step', self)
self.a_loop = QAction(
self.style().standardIcon(QStyle.SP_BrowserReload), 'Loop',
self)
self.a_loop.setCheckable(True)
toolbar.addAction(self.a_play)
toolbar.addAction(self.a_rewind)
toolbar.addAction(self.a_toend)
toolbar.addAction(self.a_step_backward)
toolbar.addAction(self.a_step_forward)
toolbar.addAction(self.a_loop)
if hasattr(self, 'save'):
self.a_save = QAction(
self.style().standardIcon(QStyle.SP_DialogSaveButton),
'Save', self)
toolbar.addAction(self.a_save)
self.a_save.triggered.connect(self.save)
hlayout.addWidget(toolbar)
self.speed = QSlider(Qt.Horizontal)
self.speed.setMinimum(0)
self.speed.setMaximum(100)
hlayout.addWidget(QLabel('Speed:'))
hlayout.addWidget(self.speed)
layout.addLayout(hlayout)
self.timer = QTimer()
self.timer.timeout.connect(self.update_solution)
self.slider.valueChanged.connect(self.slider_changed)
self.slider.valueChanged.connect(lcd.display)
self.speed.valueChanged.connect(self.speed_changed)
self.a_play.toggled.connect(self.toggle_play)
self.a_rewind.triggered.connect(self.rewind)
self.a_toend.triggered.connect(self.to_end)
self.a_step_forward.triggered.connect(self.step_forward)
self.a_step_backward.triggered.connect(self.step_backward)
self.speed.setValue(50)
elif hasattr(self, 'save'):
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_save = QAction(
self.style().standardIcon(QStyle.SP_DialogSaveButton),
'Save', self)
toolbar.addAction(self.a_save)
hlayout.addWidget(toolbar)
layout.addLayout(hlayout)
self.a_save.triggered.connect(self.save)
self.setLayout(layout)
self.plot = plot
self.U = U
self.length = length
class ToolTipWidget(QWidget, object):
hidden = Signal()
def __init__(self, parent=None):
super(ToolTipWidget, self).__init__(parent)
self._layout = None
self._content = None
self._content_parent = None
self._hide_timer = QTimer(self)
self._init()
def enterEvent(self, event):
if self.hide_delay() > 0:
self._hide_timer.stop()
else:
self.hide()
def hideEvent(self, event):
self._remove_widget()
QTimer.singleShot(0, self.hidden.emit)
def leaveEvent(self, event):
self.hide()
# def paintEvent(self, event):
# painter = QStylePainter(self)
# painter.setClipRegion(event.region())
# option = QStyleOptionFrame()
# option.init(self)
# painter.drawPrimitive(QStyle.PE_PanelTipLabel, option)
# painter.end()
#
# super(ToolTipWidget, self).paintEvent(event)
def show_at(self, pos, content, parent_window=None):
"""
Shows tooltip in given position and with given widget
:param pos: QPoint
:param content: QWidget
:param parent_window: QWindow
"""
parent_window = parent_window or dcc.get_main_window().windowHandle()
self._add_widget(content)
self._show(pos, parent_window)
def show_below(self, rect, content, parent_window=None):
"""
Shows tooltip below given rect and with given content
:param rect: QRect
:param content: QWidget
:param parent_window: QWindow
"""
parent_window = parent_window or dcc.get_main_window().windowHandle()
self._add_widget(content)
margin_size = QSize(
2 * content.style().pixelMetric(QStyle.PM_DefaultTopLevelMargin),
2 * content.style().pixelMetric(QStyle.PM_DefaultTopLevelMargin)
)
content.setMaximumSize(parent_window.screen().geometry().size() - margin_size)
self._show(self._center_below(rect, parent_window.screen()), parent_window)
def hide_delay(self):
"""
Returns timer hide interval
:return: float
"""
return self._hide_timer.interval()
def set_hide_delay(self, hide_delay_interval):
"""
Sets the delay timer value
:param hide_delay_interval: float
"""
self._hide_timer.setInterval(hide_delay_interval)
def hide_later(self):
"""
Hides tooltip if timer is over
"""
if not self.isVisible():
return
if self.hide_delay() > 0:
self._hide_timer.start()
else:
self.hide()
def _init(self):
"""
Internal function that initializes tooltip widget
"""
self.setMouseTracking(True)
self._layout = layouts.VerticalLayout(parent=self)
self._hide_timer.setSingleShot(True)
self._hide_timer.setInterval(500)
self._hide_timer.timeout.connect(self._on_timer_timeout)
# self.setAttribute(Qt.WA_TranslucentBackground)
self.setWindowFlags(Qt.ToolTip | Qt.FramelessWindowHint | Qt.NoDropShadowWindowHint)
def _add_widget(self, widget):
"""
Internal function that adds replaces current contained wiget with the given one
:param widget: QWidget
"""
self._remove_widget()
self._content = widget
self._store_parent()
self._layout.addWidget(self._content)
widget.destroyed.connect(widget.hide)
def _remove_widget(self):
"""
Internal function that removes current contained widget from the tooltip
"""
self._layout.removeWidget(self._content)
self._restore_parent()
def _show(self, pos, parent_window):
if not pos or pos.isNull():
return
offset_pos = QPoint(pos.x() - 5, pos.y() - 5)
self.move(offset_pos)
self.createWinId()
self.windowHandle().setProperty('ENABLE_BLUR_BEHIND_HINT', True)
self.windowHandle().setTransientParent(parent_window)
self.show()
def _store_parent(self):
"""
Internal function that stores parent of current contained widget
"""
if not self._content:
return
self._content_parent = self._content.parent()
def _restore_parent(self):
"""
Internal function that reparent current contained widget to current tooltip parent widget
"""
if not self._content or not self._content_parent:
return
self._content.setParent(self._content_parent)
def _center_below(self, rect, screen):
"""
Internal function that returns a position for the tooltip ensuring that:
1) The content is fully visible
2) The content is not drawn inside rect
:param rect: QRect
:param screen: QScreen
:return: QPoint
"""
size = self.sizeHint()
margin = self.style().pixelMetric(QStyle.PM_ToolTipLabelFrameWidth)
screen_geometry = screen.geometry()
has_room_to_left = (rect.left() - size.width() - margin >= screen_geometry.left())
has_room_to_right = (rect.right() + size.width() + margin <= screen_geometry.right())
has_room_above = (rect.top() - size.height() - margin >= screen_geometry.top())
has_room_below = (rect.bottom() + size.height() + margin <= screen_geometry.bottom())
if not has_room_above and not has_room_below and not has_room_to_left and not has_room_to_right:
return QPoint()
x = 0
y = 0
if has_room_below or has_room_above:
x = max(screen_geometry.left(), rect.center().x() - size.width() / 2)
if x + size.width() >= screen_geometry.right():
x = screen_geometry.right() - size.width() + 1
assert x >= 0
if has_room_below:
y = rect.bottom() + margin
else:
y = rect.top() - size.height() - margin + 1
else:
assert has_room_to_left or has_room_to_right
if has_room_to_right:
x = rect.right() + margin
else:
x = rect.left() - size.width() - margin + 1
# Put tooltip at the bottom of the screen. The x-coordinate has already been adjusted,
# so no overlapping with rect occurs
y = screen_geometry.bottom() - size.height() + 1
return QPoint(x, y)
def _on_timer_timeout(self):
self.hide()
class BaseAnimObject(object):
_glow_pens = {}
for index in range(1, 11):
_glow_pens[index] = [QPen(QColor(0, 255, 0, 12 * index), 1, Qt.SolidLine),
QPen(QColor(0, 255, 0, 5 * index), 3, Qt.SolidLine),
QPen(QColor(0, 255, 0, 2 * index), 5, Qt.SolidLine),
QPen(QColor(0, 255, 0, 25.5 * index), 1, Qt.SolidLine)]
_pens_text = QPen(QColor(202, 207, 210), 1, Qt.SolidLine)
_pens_shadow = QPen(QColor(9, 10, 12), 1, Qt.SolidLine)
_pens_border = QPen(QColor(9, 10, 12), 2, Qt.SolidLine)
_pens_clear = QPen(QColor(0, 0, 0, 0), 1, Qt.SolidLine)
_pens_text_disabled = QPen(QColor(102, 107, 110), 1, Qt.SolidLine)
_pens_shadow_disabled = QPen(QColor(0, 0, 0), 1, Qt.SolidLine)
_brush_clear = QBrush(QColor(0, 0, 0, 0))
_brush_border = QBrush(QColor(9, 10, 12))
def __init__(self):
font = QFont()
font.setPointSize(8)
font.setFamily("Calibri")
self.setFont(font)
self._hover = False
self._glow_index = 0
self._anim_timer = QTimer()
self._anim_timer.timeout.connect(self._animate_glow)
def enterEvent(self, event):
super(self.__class__, self).enterEvent(event)
if not self.isEnabled():
return
self._hover = True
self._start_anim()
def leaveEvent(self, event):
super(self.__class__, self).leaveEvent(event)
if not self.isEnabled():
return
self._hover = False
self._start_anim()
def _animate_glow(self):
if self._hover:
if self._glow_index >= 10:
self._glow_index = 10
self._anim_timer.stop()
else:
self._glow_index += 1
else:
if self._glow_index <= 0:
self._glow_index = 0
self._anim_timer.stop()
else:
self._glow_index -= 1
dcc.execute_deferred(self.update)
def _start_anim(self):
if self._anim_timer.isActive():
return
self._anim_timer.start(20)