Qt: hide widget with ToolTip flag when window is not visible - qt

Question

I'm creating a video player, below is an MRE implementation of the VideoWidget and a widget to display the video controls, called ControlBar:
import os
from PySide6 import QtMultimedia as qtm
from PySide6 import QtMultimediaWidgets as qtmw
from PySide6 import QtWidgets as qtw
from PySide6 import QtCore as qtc
from PySide6 import QtGui as qtg
class VideoWidget(qtmw.QVideoWidget):
load_finished_signal = qtc.Signal()
_playback_state_changed_signal = qtc.Signal()
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.setFocusPolicy(qtc.Qt.FocusPolicy.NoFocus)
self.setMouseTracking(True)
# In Qt6, a private internal class is used for rendering the video, so
# add `vw.children()[0].setMouseTracking(True)`
self.children()[0].setMouseTracking(True)
self._seeking = False
self._audio_output = qtm.QAudioOutput(qtm.QMediaDevices.defaultAudioOutput())
self._media_player = qtm.QMediaPlayer(self)
self._control_bar = ControlBar(self)
self._hide_control_bar_timer = qtc.QTimer()
self._media_player.setVideoOutput(self)
self._media_player.setAudioOutput(self._audio_output)
self._media_player.mediaStatusChanged.connect(self._video_loaded)
self._media_player.durationChanged.connect(
self._control_bar.update_total_duration
)
self._media_player.positionChanged.connect(self._control_bar.update_progress)
self.videoSink().videoFrameChanged.connect(self._seeked)
self._control_bar.seek_requested_signal.connect(self._seek)
self._control_bar.pause_play_requested_signal.connect(self._change_playback_state)
self._playback_state_changed_signal.connect(self._control_bar.playback_state_changed)
self._hide_control_bar_timer.setSingleShot(True)
self._hide_control_bar_timer.setInterval(1000)
self._hide_control_bar_timer.timeout.connect(self._hide_control_bar)
def _hide_control_bar(self) -> None:
if not self._control_bar.underMouse():
self._control_bar.setVisible(False)
cursor = self.cursor()
cursor.setShape(qtc.Qt.CursorShape.BlankCursor)
self.setCursor(cursor)
def load(self, location: str) -> None:
self._media_player.setSource(qtc.QUrl.fromLocalFile(location))
def _video_loaded(self, location: str) -> None:
self._control_bar.set_filename(
os.path.basename(self._media_player.source().toString())
)
if self._media_player.source():
self._media_player.play()
self.load_finished_signal.emit()
def close_item(self) -> None:
self._media_player.stop()
self._media_player.setSource(qtc.QUrl())
def _screenshot(self, video_frame: qtm.QVideoFrame):
image = video_frame.toImage()
image.save(filename)
def _update_conrol_bar_position(self) -> None:
geometry = self.geometry()
top_left_global = geometry.topLeft()
self._control_bar.update_geometry_to_width(self.width())
self._control_bar.move(
top_left_global.x(),
top_left_global.y() + geometry.height() - self._control_bar.height(),
)
def _change_playback_state(self) -> None:
if (
self._media_player.playbackState()
== qtm.QMediaPlayer.PlaybackState.PlayingState
):
self._media_player.pause()
elif (
self._media_player.playbackState()
== qtm.QMediaPlayer.PlaybackState.PausedState
or self._media_player.playbackState()
== qtm.QMediaPlayer.PlaybackState.StoppedState
):
self._media_player.play()
self._playback_state_changed_signal.emit()
def mouseMoveEvent(self, event: qtg.QMouseEvent) -> None:
if not self.cursor().shape() & qtc.Qt.CursorShape.ArrowCursor:
cursor = self.cursor()
cursor.setShape(qtc.Qt.CursorShape.ArrowCursor)
self.setCursor(cursor)
if (
not self.width() == self._control_bar.width()
or not self.geometry().contains(self._control_bar.geometry())
):
self._update_conrol_bar_position()
if not self._control_bar.isVisible():
self._control_bar.setVisible(True)
self._hide_control_bar_timer.start()
def mousePressEvent(self, event: qtg.QMouseEvent) -> None:
self._change_playback_state()
event.accept()
return
def mouseDoubleClickEvent(self, event: qtg.QMouseEvent) -> None:
F_event = qtg.QKeyEvent(
qtc.QEvent.KeyPress,
qtc.Qt.Key.Key_F,
qtc.Qt.KeyboardModifier.NoModifier,
"F",
)
qtc.QCoreApplication.sendEvent(self, F_event)
super().mouseDoubleClickEvent(event)
def resizeEvent(self, event: qtg.QResizeEvent) -> None:
super().resizeEvent(event)
self._update_conrol_bar_position()
def contextMenuEvent(self, event: qtg.QContextMenuEvent):
""""""
def keyPressEvent(self, event: qtg.QKeyEvent) -> None:
key = event.key()
if (
key == qtc.Qt.Key.Key_Left
or key == qtc.Qt.Key.Key_Right
or key == qtc.Qt.Key.Key_Less
or key == qtc.Qt.Key.Key_Greater
):
factor = (
1
if event.modifiers() == qtc.Qt.KeyboardModifier.ShiftModifier
else 60
if event.modifiers() == qtc.Qt.KeyboardModifier.ControlModifier
else 5
)
if key == qtc.Qt.Key.Key_Left:
self._seek(max(self._media_player.position() - (1000 * factor), 0))
elif key == qtc.Qt.Key.Key_Right:
self._seek(
min(
self._media_player.position() + (1000 * factor),
self._media_player.duration(),
)
)
elif key == qtc.Qt.Key.Key_F5:
self._screenshot(self.videoSink().videoFrame())
elif key == qtc.Qt.Key.Key_Space:
self._change_playback_state()
elif key == qtc.Qt.Key.Key_Down:
self._media_player.audioOutput().setVolume(
max(self._media_player.audioOutput().volume() - 0.1, 0)
)
elif key == qtc.Qt.Key.Key_Up:
self._media_player.audioOutput().setVolume(
min(self._media_player.audioOutput().volume() + 0.1, 1)
)
elif key == qtc.Qt.Key.Key_M:
self._media_player.audioOutput().setMuted(
not self._media_player.audioOutput().isMuted()
)
else:
super().keyPressEvent(event)
return None
event.accept()
return None
"""
- next in directory
- previous in directory
"""
def _seek(self, position: int) -> None:
if self._seeking:
return
self._seeking = True
if self._media_player.isSeekable():
self._media_player.setPosition(position)
else:
self._seeked()
def _seeked(self):
self._seeking = False
def wheelEvent(self, event: qtg.QWheelEvent) -> None:
"volume"
class ControlBar(qtw.QWidget):
seek_requested_signal = qtc.Signal(int)
pause_play_requested_signal = qtc.Signal()
_WRT_HEIGHT = 100
_MAX_FONT_POINT_F = 20
_WRT_WIDTH = 1920 / 2
# Height should be _WRT_HEIGHT if width is _WRT_WIDTH.
_CONTROL_BAR_WIDTH_TO_HEIGHT_RATIO = _WRT_HEIGHT / _WRT_WIDTH
_FONT_POINT_F_RATIO = _MAX_FONT_POINT_F / _WRT_HEIGHT
_WIDGETS_SIZE_RATIOS = {
"filename": (_WRT_WIDTH / _WRT_WIDTH, 40 / _WRT_HEIGHT),
"pause_play": (30 / _WRT_WIDTH, 35 / _WRT_HEIGHT),
"pause": (10 / _WRT_WIDTH, 35 / _WRT_HEIGHT),
"play": (25 / _WRT_WIDTH, 35 / _WRT_HEIGHT),
"left_duration": (0 / _WRT_WIDTH, 40 / _WRT_HEIGHT),
"right_duration": (0 / _WRT_WIDTH, 40 / _WRT_HEIGHT),
"total_progress_bar": (578 / _WRT_WIDTH, 40 / _WRT_HEIGHT),
"completed_progress_bar": (0 / _WRT_WIDTH, 40 / _WRT_HEIGHT),
}
_PADDINGS_RATIOS = {"v_pad": 5 / _WRT_HEIGHT, "h_pad": 10 / _WRT_WIDTH}
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.setWindowFlag(qtc.Qt.WindowType.ToolTip)
self._total_duration_ms = 0
self._completed_duration_ms = 0
self._widget_shapes = {
"filename_rect": qtc.QRect(),
"pause_play_button_rect": qtc.QRect(),
"pause_path": qtg.QPainterPath(),
"play_triangle": qtg.QPolygon(),
"left_duration_rect": qtc.QRect(),
"progress_bar_rect": qtc.QRect(),
"right_duration_rect": qtc.QRect(),
}
self._show_milliseconds = False
self._filename = ""
self._paused = False
def playback_state_changed(self) -> None:
self._paused = not self._paused
def paintEvent(self, event: qtg.QPaintEvent) -> None:
painter = qtg.QPainter(self)
painter.setRenderHint(qtg.QPainter.RenderHint.Antialiasing)
painter.fillRect(0, 0, self.width(), self.height(), qtc.Qt.GlobalColor.black)
pen = qtg.QPen()
pen.setColor(qtc.Qt.GlobalColor.white)
painter.setPen(pen)
painter.setFont(self._get_font())
painter.drawText(
self._widget_shapes["filename_rect"],
qtc.Qt.AlignmentFlag.AlignLeft,
self._filename,
)
if self._paused:
path = qtg.QPainterPath()
path.addPolygon(self._widget_shapes["play_triangle"])
painter.fillPath(path, qtc.Qt.GlobalColor.white)
else:
painter.fillPath(self._widget_shapes["pause_path"], qtc.Qt.GlobalColor.white)
painter.drawText(
self._widget_shapes["left_duration_rect"],
qtc.Qt.AlignmentFlag.AlignCenter,
_format_milliseconds(self._completed_duration_ms, self._show_milliseconds),
)
painter.fillRect(
self._widget_shapes["progress_bar_rect"], qtc.Qt.GlobalColor.gray
)
painter.fillRect(
self._get_completed_progress_bar_rect(), qtc.Qt.GlobalColor.white
)
painter.drawText(
self._widget_shapes["right_duration_rect"],
qtc.Qt.AlignmentFlag.AlignCenter,
_format_milliseconds(self._total_duration_ms, self._show_milliseconds),
)
def set_filename(self, filename: str) -> None:
self._filename = filename
def update_total_duration(self, duration: int) -> None:
self._total_duration_ms = duration
self.update()
def update_progress(self, progress: int) -> None:
self._completed_duration_ms = progress
self.update()
def update_geometry_to_width(self, width: int) -> None:
new_control_bar_height = int(self._CONTROL_BAR_WIDTH_TO_HEIGHT_RATIO * width)
self.setFixedSize(width, min(new_control_bar_height, self._WRT_HEIGHT))
self._update_widgets_geometry()
def _update_widgets_geometry(self) -> None:
total_height = 0
row_1_total_width = 0
row_2_total_width = 0
total_height += self.height() * self._PADDINGS_RATIOS["v_pad"]
row_1_total_width += self.width() * self._PADDINGS_RATIOS["h_pad"]
row_2_total_width += self.width() * self._PADDINGS_RATIOS["h_pad"]
font_metric = qtg.QFontMetrics(self._get_font())
horizontal_advance = font_metric.horizontalAdvance("A")
self._widget_shapes["filename_rect"].setX(row_1_total_width)
self._widget_shapes["filename_rect"].setY(total_height)
self._widget_shapes["filename_rect"].setWidth(
horizontal_advance * len(self._filename)
)
self._widget_shapes["filename_rect"].setHeight(
self.height() * self._WIDGETS_SIZE_RATIOS["filename"][1]
)
total_height += self._widget_shapes["filename_rect"].height()
row_1_total_width += self._widget_shapes["filename_rect"].width()
total_height += self.height() * self._PADDINGS_RATIOS["v_pad"]
row_1_total_width += self.width() * self._PADDINGS_RATIOS["h_pad"]
self._widget_shapes["pause_play_button_rect"].setX(row_2_total_width)
self._widget_shapes["pause_play_button_rect"].setY(total_height)
self._widget_shapes["pause_play_button_rect"].setWidth(
min(30, self.width() * self._WIDGETS_SIZE_RATIOS["pause_play"][0])
)
self._widget_shapes["pause_play_button_rect"].setHeight(
self.height() * self._WIDGETS_SIZE_RATIOS["pause_play"][1]
)
self._widget_shapes["pause_path"] = qtg.QPainterPath()
pause_1 = qtc.QRect(
self._widget_shapes["pause_play_button_rect"].x(),
self._widget_shapes["pause_play_button_rect"].y(),
min(10, self.width() * self._WIDGETS_SIZE_RATIOS["pause"][0]),
self.height() * self._WIDGETS_SIZE_RATIOS["pause"][1],
)
self._widget_shapes["pause_path"].addRect(pause_1)
pause_2 = qtc.QRect(
self._widget_shapes["pause_play_button_rect"].topRight().x(),
self._widget_shapes["pause_play_button_rect"].y(),
-min(10, self.width() * self._WIDGETS_SIZE_RATIOS["pause"][0]),
self.height() * self._WIDGETS_SIZE_RATIOS["pause"][1],
)
self._widget_shapes["pause_path"].addRect(pause_2)
self._widget_shapes["play_triangle"] = qtg.QPolygon()
right = self._widget_shapes["pause_play_button_rect"].center()
right.setX(self._widget_shapes["pause_play_button_rect"].right())
self._widget_shapes["play_triangle"].append(
[
self._widget_shapes["pause_play_button_rect"].topLeft(),
self._widget_shapes["pause_play_button_rect"].bottomLeft(),
right,
]
)
row_2_total_width += self._widget_shapes["pause_play_button_rect"].width()
row_2_total_width += self.width() * self._PADDINGS_RATIOS["h_pad"]
self._widget_shapes["left_duration_rect"].setX(row_2_total_width)
self._widget_shapes["left_duration_rect"].setY(total_height)
self._widget_shapes["left_duration_rect"].setWidth(
horizontal_advance
* len(
_format_milliseconds(
self._completed_duration_ms, self._show_milliseconds
)
)
)
self._widget_shapes["left_duration_rect"].setHeight(
self.height() * self._WIDGETS_SIZE_RATIOS["left_duration"][1]
)
row_2_total_width += self._widget_shapes["left_duration_rect"].width()
row_2_total_width += self.width() * self._PADDINGS_RATIOS["h_pad"]
self._widget_shapes["progress_bar_rect"].setX(row_2_total_width)
self._widget_shapes["progress_bar_rect"].setY(total_height)
self._widget_shapes["progress_bar_rect"].setWidth(
self.width() * self._WIDGETS_SIZE_RATIOS["total_progress_bar"][0]
)
self._widget_shapes["progress_bar_rect"].setHeight(
self.height() * self._WIDGETS_SIZE_RATIOS["total_progress_bar"][1]
)
row_2_total_width += self._widget_shapes["progress_bar_rect"].width()
row_2_total_width += self.width() * self._PADDINGS_RATIOS["h_pad"]
# To adjust the size of the progress bar according to the remaining width
# left after adding all remaining widget's widths.
theoritical_width = row_2_total_width
theoritical_width += horizontal_advance * len(
_format_milliseconds(self._total_duration_ms, self._show_milliseconds)
)
theoritical_width += self.width() * self._PADDINGS_RATIOS["h_pad"]
remaining_width = self.width() - theoritical_width
self._widget_shapes["progress_bar_rect"].setWidth(
self._widget_shapes["progress_bar_rect"].width() + remaining_width
)
row_2_total_width += remaining_width
self._widget_shapes["right_duration_rect"].setX(row_2_total_width)
self._widget_shapes["right_duration_rect"].setY(total_height)
self._widget_shapes["right_duration_rect"].setWidth(
horizontal_advance
* len(
_format_milliseconds(self._total_duration_ms, self._show_milliseconds)
)
)
self._widget_shapes["right_duration_rect"].setHeight(
self.height() * self._WIDGETS_SIZE_RATIOS["right_duration"][1]
)
row_2_total_width += self._widget_shapes["right_duration_rect"].width()
row_2_total_width += self.width() * self._PADDINGS_RATIOS["h_pad"]
def _get_font(self) -> qtg.QFont:
font = qtg.QFont()
font.setPointSizeF(self.height() * self._FONT_POINT_F_RATIO)
return font
def _get_completed_progress_bar_rect(self) -> qtc.QRect:
completed_width = int(
(self._completed_duration_ms / (self._total_duration_ms or 1))
* self._widget_shapes["progress_bar_rect"].width()
)
completed_rect = qtc.QRect(self._widget_shapes["progress_bar_rect"])
completed_rect.setWidth(completed_width)
return completed_rect
def _get_time_from_mouse_press(self, point: qtc.QPoint) -> None:
return int(
(point.x() / self._widget_shapes["progress_bar_rect"].width())
* self._total_duration_ms
)
def mousePressEvent(self, event: qtg.QMouseEvent) -> None:
point = event.pos()
if self._widget_shapes["left_duration_rect"].contains(point):
self._show_milliseconds = not self._show_milliseconds
self._update_widgets_geometry()
elif self._widget_shapes["progress_bar_rect"].contains(point):
self.seek_requested_signal.emit(
self._get_time_from_mouse_press(
point - self._widget_shapes["progress_bar_rect"].topLeft()
)
)
elif self._widget_shapes["pause_play_button_rect"].contains(point):
self.pause_play_requested_signal.emit()
self.update()
event.accept()
return
def mouseMoveEvent(self, event: qtg.QMouseEvent) -> None:
if self._widget_shapes["progress_bar_rect"].contains(event.pos()):
self.seek_requested_signal.emit(
self._get_time_from_mouse_press(
event.pos() - self._widget_shapes["progress_bar_rect"].topLeft()
)
)
event.accept()
return
def _format_milliseconds(milliseconds: int, show_milliseconds: bool = False) -> str:
seconds, milliseconds = divmod(milliseconds, 1000)
minutes, seconds = divmod(seconds, 60)
hours, minutes = divmod(minutes, 60)
return f"{hours:02}:{minutes:02}:{seconds:02}" + (
f".{milliseconds:03}" if show_milliseconds else ""
)
app = qtw.QApplication()
vw = VideoWidget()
vw.show()
vw.load("video_file")
app.exec()
While this works as expected for the most part, if I alt-tab into another window (effectively hiding the program) with the ControlBar displayed, the bar is visible on top of the other window as well. I'm guessing such is the nature of the Qt.ToolTip window flag. How do I have it "show" or "hide" with the main program?
Also, the _update_widgets_geometry() function's implementation is rather tedious, is there a better way to do this? "This" being the way I layout (set the QRects for) the shapes in the ControlBar.
EDIT:
The code should work "out of the box", just pass a valid video file path to the vw.load() at the end of the code. A screenshot.