class Slider(QWidget):
def __init__(self, name, min_value, max_value):
QWidget.__init__(self)
self.setObjectName(name)
self.slider = QSlider(Qt.Orientation.Vertical)
self.slider.setMaximum(max_value)
self.slider.setMinimum(min_value)
self.label = QLabel(name)
self.label.setAlignment(Qt.AlignCenter)
min_width = self.label.fontMetrics().boundingRect(
str(min_value)).width()
max_width = self.label.fontMetrics().boundingRect(
str(max_value)).width()
minimum_width = max(min_width, max_width)
self.value = QLabel(self.to_string(min_value))
self.value.setAlignment(Qt.AlignCenter)
self.value.setMinimumWidth(minimum_width)
self.value.setText(self.to_string(self.slider.sliderPosition()))
self.layout = QVBoxLayout()
self.layout.addWidget(self.label, alignment=Qt.AlignHCenter)
self.layout.addWidget(self.slider, alignment=Qt.AlignHCenter)
self.layout.addWidget(self.value, alignment=Qt.AlignHCenter)
self.layout.setAlignment(Qt.AlignCenter)
self.setLayout(self.layout)
self.slider.valueChanged.connect(self.callback)
def callback(self, value):
self.value.setText(self.to_string(value))
def to_string(self, value):
return f"{value}"
class DefaultExtensionsLayout(QHBoxLayout):
def __init__(self, label_name, extensions_list, default_extensions_list):
super().__init__()
self.all_labels_first_column_list = []
self.all_labels_second_column_list = []
self.label = QLabel(label_name)
self.extensions_checkable_comboBox = ExtensionsCheckableComboBox(items_list=extensions_list,
default_items_list=default_extensions_list)
self.setup_all_labels_list()
self.setup_layout()
if self.label.text().find("Audio") != -1 or self.label.text().find("Video") != -1:
self.setup_label_width_first_column()
else:
self.setup_label_width_second_column()
def setup_all_labels_list(self):
self.all_labels_first_column_list.append("Videos Extensions: ")
self.all_labels_first_column_list.append("Audios Extensions: ")
self.all_labels_second_column_list.append("Subtitles Extensions: ")
self.all_labels_second_column_list.append("Chapters Extensions: ")
def setup_layout(self):
self.addWidget(self.label)
self.addWidget(self.extensions_checkable_comboBox)
def setup_label_width_first_column(self):
width_to_be_fixed = 0
for i in range(len(self.all_labels_first_column_list)):
width_to_be_fixed = max(width_to_be_fixed, self.label.fontMetrics().boundingRect(
self.all_labels_first_column_list[i]).width())
self.label.setFixedWidth(width_to_be_fixed + 3)
def setup_label_width_second_column(self):
width_to_be_fixed = 0
for i in range(len(self.all_labels_second_column_list)):
width_to_be_fixed = max(width_to_be_fixed, self.label.fontMetrics().boundingRect(
self.all_labels_second_column_list[i]).width())
self.label.setFixedWidth(width_to_be_fixed + 3)
class DefaultDirectoryLayout(QHBoxLayout):
def __init__(self, label_name, default_directory):
super().__init__()
self.all_labels_list = []
self.label = QLabel(label_name)
self.lineEdit = DefaultDirectoryLineEdit(default_directory)
self.source_button = DefaultDirectorySourceButton()
self.clear_source_button = ClearSourceButton()
self.setup_all_labels_list()
self.setup_label_width()
self.setup_layout()
self.connect_signals()
def setup_all_labels_list(self):
self.all_labels_list.append("Videos Directory: ")
self.all_labels_list.append("Subtitles Directory: ")
self.all_labels_list.append("Audios Directory: ")
self.all_labels_list.append("Attachments Directory: ")
self.all_labels_list.append("Chapters Directory: ")
self.all_labels_list.append("Destination Directory: ")
def setup_label_width(self):
width_to_be_fixed = 0
for i in range(len(self.all_labels_list)):
width_to_be_fixed = max(
width_to_be_fixed,
self.label.fontMetrics().boundingRect(
self.all_labels_list[i]).width())
self.label.setMinimumWidth(width_to_be_fixed + 5)
def setup_layout(self):
self.addWidget(self.label)
self.addWidget(self.lineEdit)
self.addWidget(self.clear_source_button)
self.addWidget(self.source_button)
def connect_signals(self):
self.source_button.new_directory_signal.connect(self.lineEdit.setText)
self.clear_source_button.clear_signal.connect(self.lineEdit.clear)
class AudioInfoDialog(QDialog):
def __init__(self,
audios_name,
audios_delay,
audios_language,
audios_track_name,
audios_set_default,
audios_set_forced,
audios_default_value_delay,
audios_default_value_language,
audios_default_value_track_name,
audios_default_value_set_default,
audios_default_value_set_forced,
audio_set_default_disabled=False,
audio_set_forced_disabled=False,
disable_edit=False,
parent=None):
super().__init__(parent)
self.window_title = "Audio Info"
self.state = "no"
self.audios_count = len(audios_delay)
self.messageIcon = QLabel()
self.audio_tab_comboBox = InfoCellDialogTabComboBox(
hint="Audios Groups")
for i in range(self.audios_count):
self.audio_tab_comboBox.addItem("Audio #" + str(i + 1))
self.audio_tab_comboBox.setCurrentIndex(0)
self.audio_tab_comboBox.currentIndexChanged.connect(
self.update_current_audio_index)
self.current_audio_index = 0
self.disable_edit = disable_edit
self.current_audio_name = audios_name
self.current_audio_language = audios_language
self.current_audio_delay = audios_delay
self.current_audio_track_name = audios_track_name
self.current_audio_set_default = audios_set_default
self.current_audio_set_forced = audios_set_forced
self.default_audio_language = audios_default_value_language
self.default_audio_delay = audios_default_value_delay
self.default_audio_track_name = audios_default_value_track_name
self.default_audio_set_default = audios_default_value_set_default
self.default_audio_set_forced = audios_default_value_set_forced
self.audio_set_default_disabled = audio_set_default_disabled
self.audio_set_forced_disabled = audio_set_forced_disabled
self.audio_name_label = QLabel("Audio Name:")
self.audio_name_value = QLabel(
str(self.current_audio_name[self.current_audio_index]))
width_to_be_fixed = 0
for i in range(len(self.current_audio_name)):
width_to_be_fixed = max(
width_to_be_fixed,
self.audio_name_value.fontMetrics().boundingRect(
self.current_audio_name[i]).width())
self.audio_name_value.setFixedWidth(width_to_be_fixed + 10)
self.audio_delay_label = QLabel("Audio Delay:")
self.audio_delay_spin = QDoubleSpinBox()
self.setup_audio_delay_spin()
self.audio_language_label = QLabel("Audio Language:")
self.audio_language_comboBox = QComboBox()
self.setup_audio_language_comboBox()
self.audio_track_name_label = QLabel("Audio Track Name:")
self.audio_track_name_lineEdit = QLineEdit()
self.setup_audio_track_name_lineEdit()
self.audio_set_forced_label = QLabel("Audio Forced State:")
self.audio_set_forced_checkBox = QCheckBox()
self.setup_audio_set_forced_checkBox()
self.audio_set_default_label = QLabel("Audio Default State:")
self.audio_set_default_checkBox = QCheckBox()
self.setup_audio_set_default_checkBox()
self.yes_button = QPushButton("OK")
self.no_button = QPushButton("Cancel")
self.reset_button = QPushButton("Reset To Default")
self.buttons_layout = QHBoxLayout()
self.audio_delay_layout = QHBoxLayout()
self.audio_language_layout = QHBoxLayout()
self.audio_track_name_layout = QHBoxLayout()
self.audio_set_default_layout = QHBoxLayout()
self.audio_set_forced_layout = QHBoxLayout()
self.buttons_layout.addWidget(QLabel(""), stretch=3)
self.buttons_layout.addWidget(self.reset_button, stretch=2)
self.buttons_layout.addWidget(self.yes_button, stretch=2)
self.buttons_layout.addWidget(self.no_button, stretch=2)
self.buttons_layout.addWidget(QLabel(""), stretch=3)
self.audio_setting_layout = QGridLayout()
self.audio_editable_setting_layout = QFormLayout()
self.audio_editable_setting_layout.addRow(self.audio_name_label,
self.audio_name_value)
self.audio_editable_setting_layout.addRow(
self.audio_track_name_label, self.audio_track_name_lineEdit)
self.audio_editable_setting_layout.addRow(self.audio_language_label,
self.audio_language_comboBox)
self.audio_editable_setting_layout.addRow(self.audio_delay_label,
self.audio_delay_spin)
self.audio_editable_setting_layout.addRow(
self.audio_set_default_label, self.audio_set_default_checkBox)
self.audio_editable_setting_layout.addRow(
self.audio_set_forced_label, self.audio_set_forced_checkBox)
self.audio_setting_layout.addWidget(self.audio_tab_comboBox, 0, 0)
self.audio_setting_layout.addLayout(self.audio_editable_setting_layout,
1, 0, 5, 2)
self.audio_setting_layout.addWidget(self.messageIcon, 1, 3, 5, -1)
self.main_layout = QGridLayout()
self.main_layout.addLayout(self.audio_setting_layout, 0, 0, 2, 3)
self.main_layout.addLayout(self.buttons_layout, 2, 0, 1, -1)
self.main_layout.setContentsMargins(20, 20, 20, 20)
self.setLayout(self.main_layout)
self.setup_ui()
self.signal_connect()
def setup_ui(self):
self.disable_question_mark_window()
self.messageIcon.setPixmap(
QtGui.QPixmap(GlobalFiles.AudioIconPath).scaledToHeight(100))
self.set_dialog_values()
self.set_default_buttons()
if self.audio_set_default_disabled:
self.audio_set_default_disable()
if self.audio_set_forced_disabled:
self.audio_set_forced_disable()
if self.disable_edit:
self.audio_track_name_lineEdit.setEnabled(False)
self.audio_language_comboBox.setEnabled(False)
self.audio_delay_spin.setEnabled(False)
self.audio_set_default_checkBox.setEnabled(False)
self.audio_set_forced_checkBox.setEnabled(False)
self.reset_button.setEnabled(False)
self.setup_tool_tip_hint_audio_set_default()
self.setup_tool_tip_hint_audio_set_forced()
def signal_connect(self):
self.audio_track_name_lineEdit.textEdited.connect(
self.update_current_audio_track_name)
self.audio_delay_spin.editingFinished.connect(
self.update_current_audio_delay)
self.audio_language_comboBox.currentTextChanged.connect(
self.update_current_audio_language)
self.audio_set_default_checkBox.stateChanged.connect(
self.update_current_audio_set_default)
self.audio_set_forced_checkBox.stateChanged.connect(
self.update_current_audio_set_forced)
self.yes_button.clicked.connect(self.click_yes)
self.no_button.clicked.connect(self.click_no)
self.reset_button.clicked.connect(self.reset_audio_setting)
def click_yes(self):
self.state = "yes"
self.close()
def click_no(self):
self.state = "no"
self.close()
def set_dialog_values(self):
self.setWindowTitle(self.window_title)
self.setWindowIcon(GlobalFiles.InfoSettingIcon)
def disable_question_mark_window(self):
self.setWindowFlag(Qt.WindowContextHelpButtonHint, on=False)
def increase_message_font_size(self, value):
message_font = self.message.font()
message_font.setPointSize(self.message.fontInfo().pointSize() + value)
self.message.setFont(message_font)
def set_default_buttons(self):
self.yes_button.setDefault(True)
self.yes_button.setFocus()
def showEvent(self, a0: QtGui.QShowEvent) -> None:
super().showEvent(a0)
self.setFixedSize(self.size())
def setup_audio_track_name_lineEdit(self):
self.audio_track_name_lineEdit.setClearButtonEnabled(True)
self.audio_track_name_lineEdit.setText(
self.current_audio_track_name[self.current_audio_index])
def setup_audio_language_comboBox(self):
self.audio_language_comboBox.addItems(AllAudiosLanguages)
self.audio_language_comboBox.setCurrentIndex(
AllAudiosLanguages.index(
self.current_audio_language[self.current_audio_index]))
self.audio_language_comboBox.setMaxVisibleItems(8)
self.audio_language_comboBox.setStyleSheet(
"QComboBox { combobox-popup: 0; }")
def setup_audio_delay_spin(self):
# self.audio_delay_spin.setMaximumWidth(screen_size.width() // 16)
self.audio_delay_spin.setDecimals(3)
self.audio_delay_spin.setMinimum(-9999.0)
self.audio_delay_spin.setMaximum(9999.0)
self.audio_delay_spin.setSingleStep(0.5)
self.audio_delay_spin.setValue(
float(self.current_audio_delay[self.current_audio_index]))
def setup_audio_set_default_checkBox(self):
self.audio_set_default_checkBox.setText("Set Default")
self.audio_set_default_checkBox.setChecked(
bool(self.current_audio_set_default[self.current_audio_index]))
def setup_audio_set_forced_checkBox(self):
self.audio_set_forced_checkBox.setText("Set Forced")
self.audio_set_forced_checkBox.setChecked(
bool(self.current_audio_set_forced[self.current_audio_index]))
def update_current_audio_track_name(self):
self.current_audio_track_name[self.current_audio_index] = str(
self.audio_track_name_lineEdit.text())
def update_current_audio_delay(self):
self.current_audio_delay[self.current_audio_index] = round(
self.audio_delay_spin.value(), 5)
def update_current_audio_language(self):
self.current_audio_language[self.current_audio_index] = str(
self.audio_language_comboBox.currentText())
def update_current_audio_set_default(self):
new_state = self.audio_set_default_checkBox.checkState() == Qt.Checked
self.current_audio_set_default[self.current_audio_index] = new_state
if new_state:
for i in range(len(self.current_audio_set_default)):
if i != self.current_audio_index:
self.current_audio_set_default[i] = False
def update_current_audio_set_forced(self):
new_state = self.audio_set_forced_checkBox.checkState() == Qt.Checked
self.current_audio_set_forced[self.current_audio_index] = new_state
if new_state:
for i in range(len(self.current_audio_set_forced)):
if i != self.current_audio_index:
self.current_audio_set_forced[i] = False
def reset_audio_setting(self):
self.current_audio_language[
self.current_audio_index] = self.default_audio_language[
self.current_audio_index]
self.current_audio_delay[
self.current_audio_index] = self.default_audio_delay[
self.current_audio_index]
self.current_audio_track_name[
self.current_audio_index] = self.default_audio_track_name[
self.current_audio_index]
self.current_audio_set_default[
self.current_audio_index] = self.default_audio_set_default[
self.current_audio_index]
self.current_audio_set_forced[
self.current_audio_index] = self.default_audio_set_forced[
self.current_audio_index]
self.audio_language_comboBox.setCurrentIndex(
AllAudiosLanguages.index(
self.current_audio_language[self.current_audio_index]))
self.audio_delay_spin.setValue(
float(self.current_audio_delay[self.current_audio_index]))
self.audio_track_name_lineEdit.setText(
self.current_audio_track_name[self.current_audio_index])
self.audio_set_default_checkBox.setChecked(
bool(self.current_audio_set_default[self.current_audio_index]))
self.audio_set_forced_checkBox.setChecked(
bool(self.current_audio_set_forced[self.current_audio_index]))
def audio_set_default_disable(self):
self.audio_set_default_checkBox.setDisabled(True)
def audio_set_forced_disable(self):
self.audio_set_forced_checkBox.setDisabled(True)
def setup_tool_tip_hint_audio_set_default(self):
if self.audio_set_default_checkBox.isEnabled():
self.audio_set_default_checkBox.setToolTip(
"<nobr>set this audio to be the default audio track "
"when play")
self.audio_set_default_checkBox.setToolTipDuration(12000)
else:
self.audio_set_default_checkBox.setToolTip(
"<nobr>set this audio to be the default audio track when play<br><b>Disabled</b> because "
"option "
"<b>make this audio default</b> is enabled on mux setting tab "
)
self.audio_set_default_checkBox.setToolTipDuration(12000)
def setup_tool_tip_hint_audio_set_forced(self):
if self.audio_set_forced_checkBox.isEnabled():
self.audio_set_forced_checkBox.setToolTip(
"<nobr>set this audio to be the forced audio track when "
"play")
self.audio_set_forced_checkBox.setToolTipDuration(12000)
else:
self.audio_set_forced_checkBox.setToolTip(
"<nobr>set this audio to be the forced audio track when play<br><b>Disabled</b> because "
"option "
"<b>make this audio default and forced</b> is enabled on mux setting tab "
)
self.audio_set_forced_checkBox.setToolTipDuration(12000)
def update_current_audio_index(self, new_index):
self.current_audio_index = new_index
self.audio_delay_spin.setValue(
float(self.current_audio_delay[self.current_audio_index]))
self.audio_set_default_checkBox.setChecked(
bool(self.current_audio_set_default[self.current_audio_index]))
self.audio_set_forced_checkBox.setChecked(
bool(self.current_audio_set_forced[self.current_audio_index]))
self.audio_language_comboBox.setCurrentIndex(
AllAudiosLanguages.index(
self.current_audio_language[self.current_audio_index]))
self.audio_track_name_lineEdit.setText(
self.current_audio_track_name[self.current_audio_index])
self.audio_name_value.setText(
str(self.current_audio_name[self.current_audio_index]))
def execute(self):
self.exec_()
class Window(QWidget):
def __init__(self, app, parent=None):
print("Window init")
super().__init__(parent)
# self.win_event_filter = WinEventFilter("window")
# self.installNativeEventFilter(self.win_event_filter)
self.app = app
self.window_size = QtCore.QSize(400, 250)
self.window_size_offset = QtCore.QSize(0, 150)
self.window_position = QtCore.QPoint(0, 0)
self.window_position_offset = QtCore.QPoint(0, 0)
# self.setWindowFlags(
# QtCore.Qt.Window |
# QtCore.Qt.CustomizeWindowHint |
# QtCore.Qt.WindowTitleHint |
# QtCore.Qt.WindowCloseButtonHint |
# QtCore.Qt.WindowStaysOnTopHint
# )
self.setWindowFlags(self.windowFlags() |
QtCore.Qt.FramelessWindowHint)
self.setWindowFlags(self.windowFlags() |
QtCore.Qt.WindowStaysOnTopHint)
self.setWindowFlags(
QtCore.Qt.FramelessWindowHint |
QtCore.Qt.WindowStaysOnTopHint |
QtCore.Qt.Tool)
# hlayout = QHBoxLayout()
# hlayout.setMargin(0)
# hlayout.setContentsMargins(0, 0, 0, 0)
# hlayout.setSpacing(0)
# buttonslayout = QVBoxLayout()
self.labels = []
self.menuButton = QPushButton(u"\U00002261")
self.menuLabel = QLabel("Menu")
myFontBold = self.menuLabel.font()
myFontBold.setBold(True)
# buttons
myFont = self.menuButton.font()
myFont2 = self.menuButton.font()
if (myFont.pointSize() > 0):
myFont.setPointSizeF(1.25 * myFont.pointSizeF())
myFont2.setPointSizeF(1.4 * myFont.pointSizeF())
else:
myFont.setPixelSize(1.25 * myFont.pixelSize())
myFont2.setPixelSize(1.4 * myFont.pixelSize())
self.menuLabel.setFont(myFontBold)
width = self.menuButton.fontMetrics().boundingRect("OO").width() + 7
height = width # okButton.height()
self.menuButton.setFont(myFont2)
self.menuButton.setMaximumWidth(width)
self.menuButton.setMinimumWidth(width)
self.menuButton.setFlat(True)
self.menuButton.clicked.connect(self.menuPressed)
mainButton = QPushButton(u"\U0000239A")
mainLabel = QLabel("Main")
width = mainButton.fontMetrics().boundingRect("OO").width() + 7
height = width # okButton.height()
mainButton.setFont(myFont2)
mainButton.setMaximumWidth(width)
mainButton.setMinimumWidth(width)
mainButton.clicked.connect(self.main)
mainButton.setFlat(True)
setupButton = QPushButton(u"\U0001F527")
setupLabel = QLabel("Setup")
setupButton.setFont(myFont)
setupButton.setFlat(True)
setupButton.setMaximumWidth(width)
setupButton.setMinimumWidth(width)
setupButton.clicked.connect(self.setup)
identifyButton = QPushButton(u"\U00002755")
identifyLabel = QLabel("Identify")
identifyButton.setFont(myFont)
identifyButton.setFlat(True)
identifyButton.setMaximumWidth(width)
identifyButton.setMinimumWidth(width)
identifyButton.clicked.connect(self.identify)
self.refreshButton = QPushButton(u"\U000021BB")
self.refreshLabel = QLabel("Detect")
self.refreshButton.setFont(myFont)
self.refreshButton.setFlat(True)
self.refreshButton.setMaximumWidth(width)
self.refreshButton.setMinimumWidth(width)
self.refreshButton.clicked.connect(self.refreshPressed)
aboutButton = QPushButton(u"\U00002754")
aboutLabel = QLabel("About")
aboutButton.setFont(myFont)
aboutButton.setFlat(True)
aboutButton.setMaximumWidth(width)
aboutButton.setMinimumWidth(width)
aboutButton.clicked.connect(self.about)
# closeButton = QPushButton(u"\U00002573")
closeButton = QPushButton(u"\U000026CC")
closeLabel = QLabel("Close")
closeButton.setFont(myFont)
closeButton.setFlat(True)
closeButton.setMaximumWidth(width)
closeButton.setMinimumWidth(width)
closeButton.clicked.connect(self.close_)
buttongrid = QGridLayout()
buttongrid.addWidget(self.menuButton, 0, 0)
buttongrid.addWidget(mainButton, 1, 0)
buttongrid.addWidget(setupButton, 2, 0)
buttongrid.addWidget(self.refreshButton, 3, 0)
buttongrid.addWidget(identifyButton, 4, 0)
buttongrid.addWidget(aboutButton, 6, 0)
buttongrid.addWidget(closeButton, 7, 0)
buttongrid.addWidget(self.menuLabel, 0, 1)
buttongrid.addWidget(mainLabel, 1, 1)
buttongrid.addWidget(setupLabel, 2, 1)
buttongrid.addWidget(self.refreshLabel, 3, 1)
buttongrid.addWidget(identifyLabel, 4, 1)
buttongrid.addWidget(aboutLabel, 6, 1)
buttongrid.addWidget(closeLabel, 7, 1)
self.labels.append(self.menuLabel)
self.labels.append(mainLabel)
self.labels.append(setupLabel)
self.labels.append(self.refreshLabel)
self.labels.append(identifyLabel)
self.labels.append(aboutLabel)
self.labels.append(closeLabel)
self.menuLabel .mousePressEvent = self.menuLabelPressed
mainLabel .mousePressEvent = self.mainLabel
setupLabel.mousePressEvent = self.setupLabel
self.refreshLabel.mousePressEvent = self.refreshLabelPressed
identifyLabel.mousePressEvent = self.identifyLabel
aboutLabel.mousePressEvent = self.aboutLabel
closeLabel.mousePressEvent = self.closeLabel
buttongrid.setRowStretch(0, 0)
buttongrid.setRowStretch(1, 0)
buttongrid.setRowStretch(2, 0)
buttongrid.setRowStretch(3, 0)
buttongrid.setRowStretch(4, 0)
buttongrid.setRowStretch(5, 1)
buttongrid.setRowStretch(6, 0)
buttongrid.setRowStretch(7, 0)
self.labels_set_visible(False)
self.layout = QHBoxLayout()
# buttonslayout.addWidget(mainButton)
# buttonslayout.addWidget(setupButton)
# buttonslayout.addStretch(1)
# buttonslayout.addWidget(aboutButton)
# hlayout.addLayout(buttonslayout)
# hlayout.addLayout(buttongrid)
# grid.addLayout(hlayout, 1, 1)
buttongrid.setSpacing(0)
self.layout.addLayout(buttongrid)
self.body_layout = QVBoxLayout()
self.body_layout.setContentsMargins(0, 0, 0, 1)
self.body_layout.setSpacing(0)
self.title_layout = QHBoxLayout()
self.title_layout.setContentsMargins(0, 0, 0, 0)
self.title_layout.setSpacing(0)
self.titleLabel = QLabel("Monitor Control")
self.titleLabel.setWordWrap(True)
self.titleLabel.setSizeIncrement(10, 10)
myFont = self.titleLabel.font()
myFont.setBold(True)
self.titleLabel.setFont(myFont)
width = self.titleLabel.fontMetrics().boundingRect("OO").width() + 7
height = width # okButton.height()
self.titleLabel.mousePressEvent = self.mainLabel
self.backButton = QPushButton(u"\U00002190", self)
myFont = self.backButton.font()
myFont.setBold(True)
self.backButton.setFont(myFont)
self.backButton.setMaximumWidth(width)
self.backButton.setMinimumWidth(width)
self.backButton.setFlat(True)
self.backButton.clicked.connect(self.main)
self.titleLabel.setMinimumHeight(self.backButton.height())
self.title_layout.addWidget(self.backButton, 0, QtCore.Qt.AlignVCenter)
self.title_layout.addSpacing(20)
self.title_layout.addWidget(self.titleLabel, 1, QtCore.Qt.AlignVCenter)
# self.backButton.setAlignment(Qt.AlignTop)
self.title_layout.setAlignment(QtCore.Qt.AlignTop)
self.body_layout.addLayout(self.title_layout)
self.main_frame = QtWidgets.QFrame(self)
self.main_layout = QVBoxLayout()
self.feature_brightness = FeatureWidget(
self.main_frame, "Brightness", self.app.brightness)
self.feature_contrast = FeatureWidget(
self.main_frame, "Contrast", self.app.contrast)
self.main_layout.addWidget(self.feature_brightness)
self.main_layout.addWidget(self.feature_contrast)
self.main_layout.addStretch(1)
self.main_frame.setLayout(self.main_layout)
self.main_frame.hide()
self.body_layout.addWidget(self.main_frame, 1)
self.setup_frame = QtWidgets.QFrame(self)
leftButton = QPushButton("<", self.setup_frame)
width = leftButton.fontMetrics().boundingRect("<").width() + 7
leftButton.setFlat(True)
leftButton.setMaximumWidth(width)
leftButton.setMinimumWidth(width)
leftButton.setSizePolicy(QtWidgets.QSizePolicy(
QSizePolicy.Fixed, QSizePolicy.Expanding))
self.setup_layout = QHBoxLayout()
self.setup_layout.addWidget(leftButton)
self.feature_setup_widget = FeatureSetupWidget(
self.app, self.setup_frame)
# hlayout.addWidget(self.feature_setup_widget, 1)
self.feature_setup_widget.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Expanding)
rightButton = QPushButton(">", self.setup_frame)
rightButton.setFlat(True)
rightButton.setMaximumWidth(width)
rightButton.setMinimumWidth(width)
rightButton.setSizePolicy(QtWidgets.QSizePolicy(
QSizePolicy.Fixed, QSizePolicy.Expanding))
self.setup_layout.addWidget(self.feature_setup_widget, 1)
self.setup_layout.addWidget(rightButton)
self.setup_layout.setContentsMargins(0, 0, 0, 0)
self.setup_layout.setSpacing(0)
leftButton.clicked.connect(self.feature_setup_widget.previous)
rightButton.clicked.connect(self.feature_setup_widget.next)
self.setup_frame.setLayout(self.setup_layout)
# self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setSpacing(10)
self.body_layout.addWidget(self.setup_frame, 1)
self.layout.addLayout(self.body_layout, 1)
self.about_frame = QtWidgets.QFrame(self)
self.about_layout = QVBoxLayout()
self.aboutLabel1 = QLabel("About", self.about_frame)
self.aboutLabel1.setWordWrap(True)
myFont = self.aboutLabel1.font()
myFont.setBold(True)
self.aboutLabel1.setFont(myFont)
about = "©️ ™️ Juno\n\nMonitor Control synchronizes your monitor hardware properties like brightness and contrast.\nThese properties can be changed by the software sliders, or monitor buttons. These changes are monitored and read, and subsequently set to the other monitors using a calibration. This will ensure an input change has the same result on all monitors.\n"
self.aboutLabel2 = QLabel("{}".format(about), self.about_frame)
self.aboutLabel2.setAlignment(
QtCore.Qt.AlignLeft | QtCore.Qt.AlignTop)
self.aboutLabel2.setWordWrap(True)
self.about_layout.addWidget(self.aboutLabel1)
self.about_layout.addWidget(self.aboutLabel2, 1)
self.about_frame.setLayout(self.about_layout)
self.about_frame.hide()
self.body_layout.addWidget(self.about_frame, 1)
# self.layout.setSizeConstraint(QtGui.QLayout.setFixedSize)
self.setLayout(self.layout)
self.setWindowIcon(QtGui.QIcon('artifacts/icon.png'))
# set the title
self.setWindowTitle("Monitors Control")
self.main()
self.setFixedSize(400, 250)
def labels_set_visible(self, visible):
for label in self.labels:
if (self.refreshLabel == label) and visible:
self.refreshLabel.setVisible(self.refreshButton.isVisible())
else:
label.setVisible(visible)
def refresh_visible(self, visible):
if (visible):
self.refreshButton.setVisible(visible)
self.refreshLabel.setVisible(self.menuLabel.isVisible())
else:
self.refreshLabel.setVisible(visible)
self.refreshButton.setVisible(visible)
def focusOutEvent(self, event):
print('Lost focus')
def menuLabelPressed(self, event):
self.menuPressed()
def menuPressed(self):
print("Menu")
self.labels_set_visible(not self.labels[0].isVisible())
def aboutLabel(self, event):
self.about()
def about(self):
print("About")
self.setupUpdate()
self.setMinimumSize(200, 130)
# self.feature_setup_widget.hide()
self.setup_frame.hide()
self.main_frame.hide()
self.refresh_visible(False)
self.backButton.show()
self.about_frame.show()
self.move(self.window_position)
self.setFixedSize(self.window_size)
def closeLabel(self, event):
self.close_()
def close_(self):
print("Close {}".format(len(self.app.identifyWindows)))
self.setupUpdate()
if (len(self.app.identifyWindows) == 0):
self.hide()
def setupLabel(self, event):
self.setup()
def setup(self):
print("Setup")
self.move(self.window_position + self.window_position_offset)
self.setFixedSize(self.window_size + self.window_size_offset)
self.app.monitors._calibrations.loadYaml()
self.feature_setup_widget.init()
self.backButton.show()
self.main_frame.hide()
self.about_frame.hide()
self.refresh_visible(True)
self.setup_frame.show()
self.setMinimumSize(200, 130)
def setupUpdate(self):
if (self.setup_frame.isVisible()):
self.app.monitors._calibrations.saveYaml()
def mainLabel(self, event):
self.main()
def main(self):
print("Main")
self.setMinimumSize(200, 130)
self.setupUpdate()
self.refresh_visible(False)
self.backButton.hide()
# self.feature_setup_widget.hide()
self.setup_frame.hide()
self.about_frame.hide()
self.main_frame.hide()
self.move(self.window_position)
self.setFixedSize(self.window_size)
self.main_frame.show()
def identifyLabel(self, event):
self.identify()
def identify(self):
print("Identify")
self.app.identify()
def refreshLabelPressed(self, event):
self.refreshPressed()
def refreshPressed(self):
QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
print("detect")
self.feature_setup_widget.clear()
self.app.detect()
self.setup()
self.feature_setup_widget.set_infos(self.app.monitors)
self.feature_setup_widget.init()
self.app.list_monitors()
QApplication.restoreOverrideCursor()
def position_show(self):
print("position_show")
self.app.position_next_to_tray()
self.main()
self.show()
# self.requestActivate()
# QtCore.Qt.ActiveWindowFocusReason
self.activateWindow()
self.setFocus(QtCore.Qt.PopupFocusReason)
def contrast(self, value):
# from gui
self.app.contrast(value)
def brightness(self, value):
# from gui
self.app.brightness(value)
def set_contrast(self, value):
# to gui
self.feature_contrast.set_value(value)
self.feature_setup_widget.set_contrast(value)
def set_brightness(self, value):
# to gui
self.feature_brightness.set_value(value)
self.feature_setup_widget.set_brightness(value)
def show(self):
# to gui
value = self.app.monitors.get_contrast()
if (value is not None):
self.set_contrast(value)
value = self.app.monitors.get_brightness()
if (value is not None):
self.set_brightness(value)
self.feature_setup_widget.set_infos(self.app.monitors)
super().show()
class labelDlg(QDialog):
"""
Displays a floating modal text window.
If search is True, a search field editor is added on top of the window.
"""
def __init__(self,
parent=None,
title='',
wSize=QSize(500, 500),
scroll=True,
search=False,
modal=True):
super().__init__(parent)
self.setWindowTitle(parent.tr(title))
self.setStyleSheet(
" * {background-color: rgb(220, 220, 220); color: black;}\
QLabel {selection-background-color: blue; selection-color: white}\
QLineEdit {background-color: white;}")
self.setModal(modal)
self.label = QLabel()
self.label.setAlignment(Qt.AlignTop)
#self.label.setStyleSheet("selection-background-color: blue; selection-color: white}")
vl = QVBoxLayout()
if search:
ed = QLineEdit()
ed.setMaximumWidth(300)
ed.setPlaceholderText('Search')
vl = QVBoxLayout()
hl = QHBoxLayout()
hl.addWidget(ed)
button = QPushButton('Next')
button.setAutoDefault(False)
button.setMaximumWidth(60)
hl.addWidget(button)
vl.addLayout(hl)
matches = []
current = 0
def f(searchedText):
import re
nonlocal current
matches.clear()
current = 0
matches.extend([
m.span() for m in re.finditer(
searchedText, self.label.text(), re.IGNORECASE
| re.MULTILINE | re.DOTALL)
])
if matches:
item = matches[0]
self.label.setSelection(item[0], item[1] - item[0])
metrics = self.label.fontMetrics()
tabSize = 4
rect = metrics.boundingRect(
0, 0, 150000, 150000,
self.label.alignment() | Qt.TextExpandTabs,
self.label.text()[:item[1]], tabSize)
scarea.ensureVisible(0, rect.height())
def g():
nonlocal current
if not matches or not button.isDown():
return
current = (current + 1) % len(matches)
item = matches[current]
self.label.setSelection(item[0], item[1] - item[0])
metrics = self.label.fontMetrics()
tabSize = 4
rect = metrics.boundingRect(
0, 0, 150000, 150000,
self.label.alignment() | Qt.TextExpandTabs,
self.label.text()[:item[1]], tabSize)
scarea.ensureVisible(0, rect.height())
button.pressed.connect(g)
ed.textEdited.connect(f)
if scroll:
scarea = QScrollArea()
scarea.setWidget(self.label)
scarea.setWidgetResizable(True)
vl.addWidget(scarea)
else:
vl.addWidget(self.label)
self.setLayout(vl)
self.setFixedSize(wSize)
def wrapped(self, s):
"""
Returns wrapped text, according to the current font and size of label.
NOT updated when these parameters are modified.
@param s: text to wrap
@type s: str
@return:
@rtype: list of str
"""
metrics = self.label.fontMetrics()
tabSize = 4
# get max character count per line
testText = 'WWWWWWWWWWWWWWW' # start from a minimum width !
while metrics.boundingRect(0, 0, 150000, 150000,
self.label.alignment() | Qt.TextExpandTabs,
testText,
tabSize).width() < self.label.width():
testText += 'W'
# wrap text while keeping existing newlines
s = '\n'.join([
'\n'.join(
textwrap.wrap(line,
len(testText),
break_long_words=False,
replace_whitespace=False))
for line in s.splitlines()
])
return s
class SliderBar(QWidget):
value_changed = Signal(float)
def __init__(self,
title: str = '',
value: float = 0,
min_value: float = 0,
max_value: float = 100,
displayed_value_factor: float = 1,
parent: QWidget = None):
super().__init__(parent)
self._value = value
self._min_value = min_value
self._max_value = max_value
self._displayed_value_factor = displayed_value_factor
self._title_label = QLabel(title)
self._color = DEFAULT_BAR_COLOR
self._locale = QLocale(QLocale.English)
self._locale.setNumberOptions(self._locale.numberOptions()
| QLocale.RejectGroupSeparator)
validator = QDoubleValidator(self._min_value, self._max_value, 2)
validator.setNotation(QDoubleValidator.StandardNotation)
validator.setLocale(self._locale)
self._value_line_edit = SliderValueLineEdit()
self._value_line_edit.setValidator(validator)
max_label_width = self._value_line_edit.fontMetrics().width(
self._value_to_str(self.max_value))
self._value_line_edit.setFixedWidth(6 + max_label_width)
self._value_line_edit.editingFinished.connect(
self._on_value_line_edit_editing_finished)
h_layout = QHBoxLayout(self)
h_layout.setContentsMargins(4, 0, 4, 0)
# h_layout.setSpacing(0)
h_layout.addWidget(self._title_label, 0, Qt.AlignLeft)
h_layout.addWidget(self._value_line_edit, 0, Qt.AlignRight)
self._update_value_line_edit()
@property
def title(self) -> str:
return self._title_label.text()
@title.setter
def title(self, value: str):
self._title_label.setText(value)
@property
def value(self) -> float:
return self._value
@value.setter
def value(self, value: float):
value = max(min(value, self._max_value), self._min_value)
if self._value != value:
self._value = value
self._update_value_line_edit()
self.update()
self.value_changed.emit(self._value)
@property
def min_value(self) -> float:
return self._min_value
@min_value.setter
def min_value(self, value: float):
if self._min_value != value:
self._min_value = value
if self.value < self._min_value:
self.value = self._min_value
else:
self.update()
@property
def max_value(self) -> float:
return self._max_value
@max_value.setter
def max_value(self, value: float):
if self._max_value != value:
self._max_value = value
if self.value > self._max_value:
self.value = self._max_value
else:
self.update()
@property
def color(self) -> QColor:
return self._color
@color.setter
def color(self, value: QColor):
if self._color != value:
self._color = value
self.update()
@property
def font_height(self):
return self._title_label.fontMetrics().height()
def set_focus(self):
self._value_line_edit.setFocus()
def increase_value(self, factor: float = 1):
self.change_value_by_delta(1 * factor)
def decrease_value(self, factor: float = 1):
self.change_value_by_delta(-1 * factor)
def change_value_by_delta(self, delta: float):
self.value += delta
self._value_line_edit.selectAll()
def paintEvent(self, event: QPaintEvent):
super().paintEvent(event)
painter = QPainter(self)
painter.setPen(Qt.NoPen)
painter.setBrush(self.color)
painter.drawRect(
0, 0,
round((self._value - self._min_value) /
(self._max_value - self._min_value) * self.width()),
self.height())
def mouseMoveEvent(self, event: QMouseEvent):
self._update_value_by_x(event.x())
event.accept()
def mousePressEvent(self, event: QMouseEvent):
self.set_focus()
self._update_value_by_x(event.x())
event.accept()
def mouseDoubleClickEvent(self, event: QMouseEvent):
self._value_line_edit.selectAll()
event.accept()
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Up:
self.increase_value()
elif event.key() == Qt.Key_Down:
self.decrease_value()
elif event.key() == Qt.Key_PageUp:
self.increase_value(10)
elif event.key() == Qt.Key_PageDown:
self.decrease_value(10)
def wheelEvent(self, event: QWheelEvent):
value_delta = event.angleDelta().y() / 120
if event.modifiers() & Qt.ControlModifier:
value_delta *= 10
self.set_focus()
self.increase_value(value_delta)
event.accept()
def _on_value_line_edit_editing_finished(self):
self.value, ok = self._locale.toFloat(self._value_line_edit.text())
def _update_value_by_x(self, x: int):
self.value = (self.max_value -
self.min_value) * x / self.width() + self.min_value
def _update_value_line_edit(self):
self._value_line_edit.setText(self._value_to_str(self.value))
def _value_to_str(self, value: float) -> str:
return self._locale.toString(
float(value * self._displayed_value_factor), 'f', 2)
