B!P&$LX9gr>L7Uf3YEog^OX
z=nnSMBJt!NxdyrRiOYRvEODcC=*4daDmGpkemSyGd9?hGvIA2n+H3x{emVOpI_H}_
zDzO}jU-{Gi)kQa6Yo7Rf#x$PVwdn};`b90L;2~wI-hwT6IGK+Ti?mlr0{pkvcX+<^
zx!kAzF&(Tp)cc)A{Ysf2z$-}#uZx3JO_C?v%4fqx$upP3DTd
znsP0viZ&;;4$5}&Oq*mUAneyRPcJlYFn(~YXy@R2^B>6tEtM$(;vUk{_Zzs6cKw}c
zq=18S`X5x3cgt9W-0xHNp5L2Tn{NADW)`iXo&Pf+_Y;=!_ap&)tS7jo;oS>mCx67*
zwqMLMC#io}CJ5km(*NVeEPba1t2Fs#%7!NI?|u5?Hxu3oZ=-Fzp?~lp>LW72OFBI5
V8ByYO+g`m|dbP(qQ7rmg`xm0p!`T1;
diff --git a/scripts/build.bat b/scripts/build.bat
index d7ccc27f..f8a5f6b8 100644
--- a/scripts/build.bat
+++ b/scripts/build.bat
@@ -1 +1,2 @@
+CALL "%~p0compile_resources.bat"
pyinstaller -w -F --icon=res\icon.ico "%~p0..\src\AutoSplit.py"
diff --git a/scripts/compile_resources.bat b/scripts/compile_resources.bat
index 91f134e4..a6c092aa 100644
--- a/scripts/compile_resources.bat
+++ b/scripts/compile_resources.bat
@@ -1,5 +1,5 @@
cd "%~dp0.."
-pyuic6 ".\res\about.ui" -o ".\src\about.py"
-pyuic6 ".\res\design.ui" -o ".\src\design.py"
-pyuic6 ".\res\update_checker.ui" -o ".\src\update_checker.py"
-pyside6-rcc ".\res\resources.qrc" -o ".\src\resources_rc.py"
+pyuic6 ".\res\about.ui" -o ".\src\gen\about.py"
+pyuic6 ".\res\design.ui" -o ".\src\gen\design.py"
+pyuic6 ".\res\update_checker.ui" -o ".\src\gen\update_checker.py"
+pyside6-rcc ".\res\resources.qrc" -o ".\src\gen\resources_rc.py"
diff --git a/scripts/install.bat b/scripts/install.bat
index 8b34f808..b32ff99e 100644
--- a/scripts/install.bat
+++ b/scripts/install.bat
@@ -1,2 +1,4 @@
py -3.9 -m pip install wheel
py -3.9 -m pip install -r "%~p0requirements.txt"
+npm install -g pyright
+CALL "%~p0compile_resources.bat"
diff --git a/scripts/lint.ps1 b/scripts/lint.ps1
new file mode 100644
index 00000000..97a72d41
--- /dev/null
+++ b/scripts/lint.ps1
@@ -0,0 +1,11 @@
+echo "`nRunning Pyright..."
+pyright
+
+echo "`nRunning Pylint..."
+pylint --score=n --output-format=colorized $(git ls-files '**/*.py*')
+
+echo "`nRunning Bandit..."
+bandit -f custom --silent --recursive src
+
+echo "`nRunning Flake8..."
+flake8
diff --git a/scripts/requirements.txt b/scripts/requirements.txt
index 46f9939b..30cf1dab 100644
--- a/scripts/requirements.txt
+++ b/scripts/requirements.txt
@@ -5,26 +5,29 @@
# Usage: .\scripts\install.bat
#
# If you're having issues with the libraries, you might want to first run:
-# pip3.9 uninstall -r requirements.txt
+# pip3.9 uninstall -r .\scripts\requirements.txt
#
# Creating AutoSplit.exe with PyInstaller: .\scripts\build.bat
#
# Dependencies:
+numpy>=1.22.0rc1
+opencv-python<=4.5.3.56 # https://github.com/pyinstaller/pyinstaller-hooks-contrib/issues/110
PyQt6
-opencv-python<=4.5.3.56 # https://github.com/pyinstaller/pyinstaller-hooks-contrib/issues/110
+PyQt6-tools
+PySide6
Pillow
ImageHash
pywin32
keyboard
packaging
pyautogui
-PySide6
-flake8
requests
+# Linting and Types
+pywin32-stubs
types-requests
+flake8
+pylint
+bandit
#
# Comment this out if you don't want to build AutoSplit.exe:
PyInstaller
-#
-# Comment this out if you don't want to install the PyQt designer
-PyQt6-tools
diff --git a/scripts/start.bat b/scripts/start.bat
new file mode 100644
index 00000000..3b428f1d
--- /dev/null
+++ b/scripts/start.bat
@@ -0,0 +1,2 @@
+CALL "%~p0compile_resources.bat"
+py -3.9 "%~p0..\src\AutoSplit.py"
diff --git a/src/AutoControlledWorker.py b/src/AutoControlledWorker.py
new file mode 100644
index 00000000..7ef33a0c
--- /dev/null
+++ b/src/AutoControlledWorker.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+ from AutoSplit import AutoSplit
+from PyQt6 import QtCore
+
+import error_messages
+import settings_file as settings
+
+
+class AutoControlledWorker(QtCore.QObject):
+ def __init__(self, autosplit: AutoSplit):
+ self.autosplit = autosplit
+ super().__init__()
+
+ def run(self):
+ while True:
+ try:
+ line = input()
+ except RuntimeError:
+ self.autosplit.showErrorSignal.emit(error_messages.stdinLostError)
+ break
+ # TODO: "AutoSplit Integration" needs to call this and wait instead of outright killing the app.
+ # TODO: See if we can also get LiveSplit to wait on Exit in "AutoSplit Integration"
+ # For now this can only used in a Development environment
+ if line == "kill":
+ self.autosplit.closeEvent()
+ break
+ if line == "start":
+ self.autosplit.startAutoSplitter()
+ elif line in {"split", "skip"}:
+ self.autosplit.startSkipSplit()
+ elif line == "undo":
+ self.autosplit.startUndoSplit()
+ elif line == "reset":
+ self.autosplit.startReset()
+ elif line.startswith("settings"):
+ # Allow for any split character between "settings" and the path
+ self.autosplit.load_settings_file_path = line[9:]
+ settings.loadSettings(self.autosplit, load_settings_from_livesplit=True)
+ # TODO: Not yet implemented in AutoSplit Integration
+ # elif line == 'pause':
+ # self.startPause()
diff --git a/src/AutoSplit.py b/src/AutoSplit.py
index 61fcd70f..002857d3 100644
--- a/src/AutoSplit.py
+++ b/src/AutoSplit.py
@@ -1,29 +1,44 @@
-#!/usr/bin/python3.9
+#!/usr/bin/python3
# -*- coding: utf-8 -*-
-import traceback
-from types import FunctionType
-from typing import Callable, List, Optional
-from copy import copy
-from PyQt6 import QtCore, QtGui, QtTest, QtWidgets
-from win32 import win32gui
+# Imports grouping:
+# - Typings
+# - Standards
+# - Externals
+# - Internals
+from __future__ import annotations
+from collections.abc import Callable
+from types import FunctionType, TracebackType
+from typing import Literal, Optional, Union, cast
+
import sys
import os
-import cv2
-import ctypes.wintypes
import ctypes
-import numpy as np
import signal
-import time
+import traceback
+from copy import copy
+from time import time
+
+import cv2
+import numpy as np
+from PyQt6 import QtCore, QtGui, QtTest
+from PyQt6.QtWidgets import QApplication, QFileDialog, QMainWindow, QMessageBox, QWidget
+from win32 import win32gui
+from win32con import MAXBYTE
-from menu_bar import about, VERSION, viewHelp, checkForUpdates, open_update_checker
-from settings_file import auto_split_directory, FROZEN
-from split_parser import BELOW_FLAG, DUMMY_FLAG, PAUSE_FLAG
-import capture_windows
-import compare
-import design
import error_messages
+import settings_file as settings
import split_parser
+from AutoControlledWorker import AutoControlledWorker
+from capture_windows import capture_region, Rect
+from compare import checkIfImageHasTransparency, compareImage
+from gen import about, design, update_checker
+from hotkeys import send_command, afterSettingHotkey, setSplitHotkey, setResetHotkey, setSkipSplitHotkey, \
+ setUndoSplitHotkey, setPauseHotkey
+from menu_bar import open_about, VERSION, viewHelp, checkForUpdates, open_update_checker
+from screen_region import selectRegion, selectWindow, alignRegion, validateBeforeComparison
+from settings_file import FROZEN
+from split_parser import BELOW_FLAG, DUMMY_FLAG, PAUSE_FLAG
# Resize to these width and height so that FPS performance increases
COMPARISON_RESIZE_WIDTH = 320
@@ -35,18 +50,27 @@
CREATE_NEW_ISSUE_MESSAGE = "Please create a New Issue at " \
"github.com/Toufool/Auto-Split/issues, describe what happened, and copy & paste the error message below"
-class AutoSplit(QtWidgets.QMainWindow, design.Ui_MainWindow):
- from hotkeys import send_command
- from settings_file import saveSettings, saveSettingsAs, loadSettings, haveSettingsChanged, getSaveSettingsValues, \
- load_check_for_updates_on_open, set_check_for_updates_on_open
- from screen_region import selectRegion, selectWindow, alignRegion, validateBeforeComparison
- from hotkeys import afterSettingHotkey, beforeSettingHotkey, setSplitHotkey, setResetHotkey, setSkipSplitHotkey, \
- setUndoSplitHotkey, setPauseHotkey
- myappid = f'Toufool.AutoSplit.v{VERSION}'
+def make_excepthook(main_window: AutoSplit):
+ def excepthook(exception_type: type[BaseException], exception: BaseException, _traceback: Optional[TracebackType]):
+ # Catch Keyboard Interrupts for a clean close
+ if exception_type is KeyboardInterrupt or isinstance(exception, KeyboardInterrupt):
+ sys.exit(0)
+ main_window.showErrorSignal.emit(lambda: error_messages.exceptionTraceback(
+ "AutoSplit encountered an unhandled exception and will try to recover, "
+ f"however, there is no guarantee everything will work properly. {CREATE_NEW_ISSUE_MESSAGE}",
+ exception))
+ return excepthook
+
+
+class AutoSplit(QMainWindow, design.Ui_MainWindow):
+ myappid = f"Toufool.AutoSplit.v{VERSION}"
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
- # signals
+ # Parse command line args
+ is_auto_controlled = "--auto-controlled" in sys.argv
+
+ # Signals
updateCurrentSplitImage = QtCore.pyqtSignal(QtGui.QImage)
startAutoSplitterSignal = QtCore.pyqtSignal()
resetSignal = QtCore.pyqtSignal()
@@ -58,28 +82,103 @@ class AutoSplit(QtWidgets.QMainWindow, design.Ui_MainWindow):
# Use this signal when trying to show an error from outside the main thread
showErrorSignal = QtCore.pyqtSignal(FunctionType)
- def __init__(self, parent=None):
+ # Timers
+ timerLiveImage = QtCore.QTimer()
+ timerStartImage = QtCore.QTimer()
+
+ # Windows
+ AboutWidget: about.Ui_aboutAutoSplitWidget
+ UpdateCheckerWidget: update_checker.Ui_UpdateChecker
+ CheckForUpdatesThread: QtCore.QThread
+
+ # Settings
+ split_image_directory = ""
+ similarity_threshold: float
+ comparison_index: int
+ pause: float
+ fps_limit: int
+ split_key = ""
+ reset_key = ""
+ skip_split_key = ""
+ undo_split_key = ""
+ pause_key = ""
+ hwnd_title = ""
+ group_dummy_splits_undo_skip_setting: Literal[0, 1]
+ loop_setting: Literal[0, 1]
+ auto_start_on_reset_setting: Literal[0, 1]
+
+ # Default Settings for the region capture
+ hwnd = 0
+ selection = Rect()
+
+ # hotkeys need to be initialized to be passed as thread arguments in hotkeys.py
+ # and for type safety in both hotkeys.py and settings_file.py
+ split_hotkey: Optional[Callable[[], None]] = None
+ reset_hotkey: Optional[Callable[[], None]] = None
+ skip_split_hotkey: Optional[Callable[[], None]] = None
+ undo_split_hotkey: Optional[Callable[[], None]] = None
+ pause_hotkey: Optional[Callable[[], None]] = None
+
+ # Initialize a few attributes
+ last_saved_settings: Optional[list[Union[str, float, int]]] = None
+ save_settings_file_path = ""
+ load_settings_file_path = ""
+ live_image_function_on_open = True
+ split_image_loop_amount: list[int] = []
+ split_image_number = 0
+ loop_number = 1
+
+ # Last loaded settings and last successful loaded settings file path to None until we try to load them
+ last_loaded_settings: Optional[list[Union[str, float, int]]] = None
+ last_successfully_loaded_settings_file_path: Optional[str] = None
+
+ # Automatic timer start
+ timerStartImage_is_running = False
+ start_image = None
+ highest_similarity = 0.0
+ check_start_image_timestamp = 0.0
+
+ # Define all other attributes
+ setting_check_for_updates_on_open: QtCore.QSettings
+ imageHasTransparency: bool
+ start_image_split_below_threshold: bool
+ waiting_for_split_delay: bool
+ split_below_threshold: bool
+ split_image_path: str
+ split_image_filenames: list[str]
+ split_image_filenames_including_loops: list[str]
+ split_image_filenames_and_loop_number: list[tuple[str, int, int]]
+ split_groups: list[list[int]]
+ run_start_time: float
+ similarity: float
+ reset_image_threshold: float
+ reset_image_pause_time: float
+ split_delay: float
+ flags: int
+ reset_image: Optional[cv2.ndarray]
+ reset_mask: Optional[cv2.ndarray]
+ split_image: cv2.ndarray
+ image_mask: Optional[cv2.ndarray]
+
+ def __init__(self, parent: Optional[QWidget] = None):
super().__init__(parent)
# Setup global error handling
self.showErrorSignal.connect(lambda errorMessageBox: errorMessageBox())
# Whithin LiveSplit excepthook needs to use main_window's signals to show errors
- sys.excepthook = lambda _, exception, __: excepthook(exception, self)
+ sys.excepthook = make_excepthook(self)
self.setupUi(self)
- self.load_check_for_updates_on_open()
-
- # Parse command line args
- self.is_auto_controlled = ('--auto-controlled' in sys.argv)
+ settings.loadPyQtSettings(self)
# close all processes when closing window
self.actionView_Help.triggered.connect(viewHelp)
- self.actionAbout.triggered.connect(lambda: about(self))
+ self.actionAbout.triggered.connect(lambda: open_about(self))
self.actionCheck_for_Updates.triggered.connect(lambda: checkForUpdates(self))
- self.actionSave_Settings.triggered.connect(self.saveSettings)
- self.actionSave_Settings_As.triggered.connect(self.saveSettingsAs)
- self.actionLoad_Settings.triggered.connect(self.loadSettings)
+ self.actionSave_Settings.triggered.connect(lambda: settings.saveSettings(self))
+ self.actionSave_Settings_As.triggered.connect(lambda: settings.saveSettingsAs(self))
+ self.actionLoad_Settings.triggered.connect(lambda: settings.loadSettings(self))
# disable buttons upon open
self.undosplitButton.setEnabled(False)
@@ -103,68 +202,35 @@ def __init__(self, parent=None):
# Send version and process ID to stdout
print(f"{VERSION}\n{os.getpid()}", flush=True)
- class Worker(QtCore.QObject):
- def __init__(self, autosplit: AutoSplit):
- self.autosplit = autosplit
- super().__init__()
-
- def run(self):
- while True:
- try:
- line = input()
- except RuntimeError:
- self.autosplit.showErrorSignal.emit(error_messages.stdinLostError)
- break
- # TODO: "AutoSplit Integration" needs to call this and wait instead of outright killing the app.
- # TODO: See if we can also get LiveSplit to wait on Exit in "AutoSplit Integration"
- # For now this can only used in a Development environment
- if line == 'kill':
- self.autosplit.closeEvent()
- break
- elif line == 'start':
- self.autosplit.startAutoSplitter()
- elif line == 'split' or line == 'skip':
- self.autosplit.startSkipSplit()
- elif line == 'undo':
- self.autosplit.startUndoSplit()
- elif line == 'reset':
- self.autosplit.startReset()
- elif line.startswith('settings'):
- # Allow for any split character between "settings" and the path
- self.autosplit.load_settings_file_path = line[9:]
- self.autosplit.loadSettings(load_settings_from_livesplit=True)
- # TODO: Not yet implemented in AutoSplit Integration
- # elif line == 'pause':
- # self.startPause()
-
# Use and Start the thread that checks for updates from LiveSplit
self.update_auto_control = QtCore.QThread()
- worker = Worker(self)
+ worker = AutoControlledWorker(self)
worker.moveToThread(self.update_auto_control)
self.update_auto_control.started.connect(worker.run)
self.update_auto_control.start()
# split image folder line edit text
- self.splitimagefolderLineEdit.setText('No Folder Selected')
+ self.splitimagefolderLineEdit.setText("No Folder Selected")
# Connecting button clicks to functions
self.browseButton.clicked.connect(self.browse)
- self.selectregionButton.clicked.connect(self.selectRegion)
+ self.selectregionButton.clicked.connect(lambda: selectRegion(self))
self.takescreenshotButton.clicked.connect(self.takeScreenshot)
self.startautosplitterButton.clicked.connect(self.autoSplitter)
self.checkfpsButton.clicked.connect(self.checkFPS)
self.resetButton.clicked.connect(self.reset)
self.skipsplitButton.clicked.connect(self.skipSplit)
self.undosplitButton.clicked.connect(self.undoSplit)
- self.setsplithotkeyButton.clicked.connect(self.setSplitHotkey)
- self.setresethotkeyButton.clicked.connect(self.setResetHotkey)
- self.setskipsplithotkeyButton.clicked.connect(self.setSkipSplitHotkey)
- self.setundosplithotkeyButton.clicked.connect(self.setUndoSplitHotkey)
- self.setpausehotkeyButton.clicked.connect(self.setPauseHotkey)
- self.alignregionButton.clicked.connect(self.alignRegion)
- self.selectwindowButton.clicked.connect(self.selectWindow)
+ self.setsplithotkeyButton.clicked.connect(lambda: setSplitHotkey(self))
+ self.setresethotkeyButton.clicked.connect(lambda: setResetHotkey(self))
+ self.setskipsplithotkeyButton.clicked.connect(lambda: setSkipSplitHotkey(self))
+ self.setundosplithotkeyButton.clicked.connect(lambda: setUndoSplitHotkey(self))
+ self.setpausehotkeyButton.clicked.connect(lambda: setPauseHotkey(self))
+ self.alignregionButton.clicked.connect(lambda: alignRegion(self))
+ self.selectwindowButton.clicked.connect(lambda: selectWindow(self))
self.startImageReloadButton.clicked.connect(lambda: self.loadStartImage(True, True))
- self.actionCheck_for_Updates_on_Open.changed.connect(lambda: self.set_check_for_updates_on_open(
+ self.actionCheck_for_Updates_on_Open.changed.connect(lambda: settings.set_check_for_updates_on_open(
+ self,
self.actionCheck_for_Updates_on_Open.isChecked())
)
@@ -176,7 +242,7 @@ def run(self):
# connect signals to functions
self.updateCurrentSplitImage.connect(self.updateSplitImageGUI)
- self.afterSettingHotkeySignal.connect(self.afterSettingHotkey)
+ self.afterSettingHotkeySignal.connect(lambda: afterSettingHotkey(self))
self.startAutoSplitterSignal.connect(self.autoSplitter)
self.updateCheckerWidgetSignal.connect(lambda latest_version, check_on_open:
open_update_checker(self, latest_version, check_on_open))
@@ -186,64 +252,36 @@ def run(self):
# live image checkbox
self.liveimageCheckBox.clicked.connect(self.checkLiveImage)
- self.timerLiveImage = QtCore.QTimer()
self.timerLiveImage.timeout.connect(self.liveImageFunction)
- # Initialize a few attributes
- self.last_saved_settings = None
- self.live_image_function_on_open = True
- self.split_image_loop_amount = []
- self.split_image_number = 0
- self.split_image_directory = ""
-
- # hotkeys need to be initialized to be passed as thread arguments in hotkeys.py
- # and for type safety in both hotkeys.py and settings_file.py
- self.split_hotkey: Optional[Callable[[], None]] = None
- self.reset_hotkey: Optional[Callable[[], None]] = None
- self.skip_split_hotkey: Optional[Callable[[], None]] = None
- self.undo_split_hotkey: Optional[Callable[[], None]] = None
- self.pause_hotkey: Optional[Callable[[], None]] = None
- self.split_key = ""
- self.reset_key = ""
- self.skip_split_key = ""
- self.undo_split_key = ""
- self.undo_split_key = ""
-
- # Default Settings for the region capture
- self.hwnd = 0
- self.hwnd_title = ''
- self.rect = ctypes.wintypes.RECT()
-
# Automatic timer start
- self.timerStartImage = QtCore.QTimer()
self.timerStartImage.timeout.connect(self.startImageFunction)
- self.timerStartImage_is_running = False
- self.start_image = None
- self.highest_similarity = 0.0
- self.check_start_image_timestamp = 0.0
# Last loaded settings and last successful loaded settings file path to None until we try to load them
self.last_loaded_settings = None
self.last_successfully_loaded_settings_file_path = None
if not self.is_auto_controlled:
- self.loadSettings(load_settings_on_open=True)
+ settings.loadSettings(self, load_settings_on_open=True)
self.show()
# Needs to be after Ui_MainWindow.show() to be shown overtop
if self.actionCheck_for_Updates_on_Open.isChecked():
checkForUpdates(self, check_on_open=True)
-
+
# FUNCTIONS
+ def getGlobalSettingsValues(self):
+ self.setting_check_for_updates_on_open = QtCore.QSettings("AutoSplit", "Check For Updates On Open")
+
# TODO add checkbox for going back to image 1 when resetting.
def browse(self):
# User selects the file with the split images in it.
- new_split_image_directory = QtWidgets.QFileDialog.getExistingDirectory(
- self,
- 'Select Split Image Directory',
- os.path.join(self.split_image_directory or auto_split_directory, ".."))
+ new_split_image_directory = QFileDialog.getExistingDirectory(
+ self,
+ "Select Split Image Directory",
+ os.path.join(self.split_image_directory or settings.auto_split_directory, ".."))
# If the user doesn't select a folder, it defaults to "".
if new_split_image_directory:
@@ -261,21 +299,24 @@ def checkLiveImage(self):
def liveImageFunction(self):
try:
- if win32gui.GetWindowText(self.hwnd) == '':
+ windowText = win32gui.GetWindowText(self.hwnd)
+ self.captureregionwindowLabel.setText(windowText)
+ if not windowText:
self.timerLiveImage.stop()
+ self.liveImage.clear()
if self.live_image_function_on_open:
self.live_image_function_on_open = False
else:
- self.liveImage.clear()
error_messages.regionError()
return
- capture = capture_windows.capture_region(self.hwnd, self.rect)
- capture = cv2.resize(capture, DISPLAY_RESIZE)
+ capture = capture_region(self.hwnd, self.selection, self.forcePrintWindowCheckBox.isChecked())
+ capture = cv2.resize(capture, DISPLAY_RESIZE, interpolation=cv2.INTER_NEAREST)
+
capture = cv2.cvtColor(capture, cv2.COLOR_BGRA2RGB)
# Convert to set it on the label
- qImage = QtGui.QImage(capture,
+ qImage = QtGui.QImage(cast(bytes, capture),
capture.shape[1],
capture.shape[0],
capture.shape[1] * 3,
@@ -286,31 +327,35 @@ def liveImageFunction(self):
except AttributeError:
pass
- def loadStartImage(self, started_by_button=False, wait_for_delay=True):
+ def loadStartImage(self, started_by_button: bool = False, wait_for_delay: bool = True):
self.timerStartImage.stop()
- self.currentsplitimagefileLabel.setText(' ')
+ self.currentsplitimagefileLabel.setText(" ")
self.startImageLabel.setText("Start image: not found")
- QtWidgets.QApplication.processEvents()
+ QApplication.processEvents()
- if not self.validateBeforeComparison(started_by_button):
+ if not validateBeforeComparison(self, started_by_button):
return
self.start_image_name = None
for image in os.listdir(self.split_image_directory):
- if 'start_auto_splitter' in image.lower():
+ if "start_auto_splitter" in image.lower():
if self.start_image_name is None:
self.start_image_name = image
else:
if started_by_button:
- error_messages.multipleKeywordImagesError('start_auto_splitter')
+ error_messages.multipleKeywordImagesError("start_auto_splitter")
return
if self.start_image_name is None:
if started_by_button:
- error_messages.noKeywordImageError('start_auto_splitter')
+ error_messages.noKeywordImageError("start_auto_splitter")
return
- if self.start_image_name is not None and (not self.splitLineEdit.text() or not self.resetLineEdit.text() or not self.pausehotkeyLineEdit.text()) and not self.is_auto_controlled:
+ if self.start_image_name is not None \
+ and not self.is_auto_controlled \
+ and (not self.splitLineEdit.text()
+ or not self.resetLineEdit.text()
+ or not self.pausehotkeyLineEdit.text()):
error_messages.loadStartImageError()
return
@@ -324,28 +369,28 @@ def loadStartImage(self, started_by_button=False, wait_for_delay=True):
error_messages.imageTypeError(path)
return
# if image has transparency, create a mask
- self.imageHasTransparency = compare.checkIfImageHasTransparency(self.start_image)
+ self.imageHasTransparency = checkIfImageHasTransparency(self.start_image)
if self.imageHasTransparency:
self.start_image = cv2.resize(self.start_image, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
# Create mask based on resized, nearest neighbor interpolated split image
lower = np.array([0, 0, 0, 1], dtype="uint8")
- upper = np.array([255, 255, 255, 255], dtype="uint8")
+ upper = np.array([MAXBYTE, MAXBYTE, MAXBYTE, MAXBYTE], dtype="uint8")
self.start_image_mask = cv2.inRange(self.start_image, lower, upper)
# set split image as BGR
self.start_image = cv2.cvtColor(self.start_image, cv2.COLOR_BGRA2BGR)
- # otherwise, open image normally. Capture with nearest neighbor interpolation only if the split image has transparency to support older setups.
+ # otherwise, open image normally.
else:
self.start_image = cv2.imread(path, cv2.IMREAD_COLOR)
- self.start_image = cv2.resize(self.start_image, COMPARISON_RESIZE)
+ self.start_image = cv2.resize(self.start_image, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
start_image_pause = split_parser.pause_from_filename(self.start_image_name)
if not wait_for_delay and start_image_pause is not None and start_image_pause > 0:
- self.check_start_image_timestamp = time.time() + start_image_pause
+ self.check_start_image_timestamp = time() + start_image_pause
self.startImageLabel.setText("Start image: paused")
- self.highestsimilarityLabel.setText(' ')
- self.currentsimilaritythresholdnumberLabel.setText(' ')
+ self.highestsimilarityLabel.setText(" ")
+ self.currentsimilaritythresholdnumberLabel.setText(" ")
else:
self.check_start_image_timestamp = 0.0
self.startImageLabel.setText("Start image: ready")
@@ -355,12 +400,17 @@ def loadStartImage(self, started_by_button=False, wait_for_delay=True):
self.start_image_split_below_threshold = False
self.timerStartImage.start(int(1000 / self.fpslimitSpinBox.value()))
- QtWidgets.QApplication.processEvents()
+ QApplication.processEvents()
def startImageFunction(self):
- if time.time() < self.check_start_image_timestamp:
- pause_time_left = "{:.1f}".format(self.check_start_image_timestamp - time.time())
- self.currentSplitImage.setText(f'None\n (Paused before loading Start Image).\n {pause_time_left} sec remaining')
+
+ if self.start_image is None \
+ or not self.start_image_name \
+ or time() < self.check_start_image_timestamp \
+ or (not self.splitLineEdit.text() and not self.is_auto_controlled):
+ pause_time_left = f"{self.check_start_image_timestamp - time():.1f}"
+ self.currentSplitImage.setText(
+ f"None\n (Paused before loading Start Image).\n {pause_time_left} sec remaining")
return
if self.check_start_image_timestamp > 0:
@@ -369,17 +419,21 @@ def startImageFunction(self):
self.updateSplitImage(self.start_image_name, from_start_image=True)
capture = self.getCaptureForComparison()
- start_image_similarity = self.compareImage(self.start_image, self.start_image_mask, capture)
+ start_image_similarity = compareImage(
+ self.comparisonmethodComboBox.currentIndex(),
+ self.start_image,
+ capture,
+ self.start_image_mask)
start_image_threshold = split_parser.threshold_from_filename(self.start_image_name) \
or self.similaritythresholdDoubleSpinBox.value()
- self.currentsimilaritythresholdnumberLabel.setText("{:.2f}".format(start_image_threshold))
+ self.currentsimilaritythresholdnumberLabel.setText(f"{start_image_threshold:.2f}")
start_image_flags = split_parser.flags_from_filename(self.start_image_name)
start_image_delay = split_parser.delay_from_filename(self.start_image_name)
# Show live similarity if the checkbox is checked
self.livesimilarityLabel.setText(str(start_image_similarity)[:4]
if self.showlivesimilarityCheckBox.isChecked()
- else ' ')
+ else " ")
# If the similarity becomes higher than highest similarity, set it as such.
if start_image_similarity > self.highest_similarity:
@@ -388,7 +442,7 @@ def startImageFunction(self):
# Show live highest similarity if the checkbox is checked
self.highestsimilarityLabel.setText(str(self.highest_similarity)[:4]
if self.showlivesimilarityCheckBox.isChecked()
- else ' ')
+ else " ")
# If the {b} flag is set, let similarity go above threshold first, then split on similarity below threshold
# Otherwise just split when similarity goes above threshold
@@ -400,11 +454,11 @@ def startImageFunction(self):
if (start_image_flags & BELOW_FLAG == BELOW_FLAG
and self.start_image_split_below_threshold
and start_image_similarity < start_image_threshold) \
- or (start_image_similarity >= start_image_threshold and start_image_flags & BELOW_FLAG == 0):
+ or (start_image_similarity >= start_image_threshold and not start_image_flags & BELOW_FLAG):
def split():
- self.hasSentStart = False
- self.send_command("start")
- time.sleep(1 / self.fpslimitSpinBox.value())
+ send_command(self, "start")
+ # Email sent to pyqt@riverbankcomputing.com
+ QtTest.QTest.qWait(1 / self.fpslimitSpinBox.value()) # type: ignore
self.startAutoSplitter()
self.timerStartImage.stop()
@@ -413,11 +467,12 @@ def split():
# delay start image if needed
if start_image_delay > 0:
self.startImageLabel.setText("Start image: delaying start...")
- delay_start_time = time.time()
- while time.time() - delay_start_time < (start_image_delay / 1000):
- delay_time_left = round((start_image_delay / 1000) - (time.time() - delay_start_time), 1)
- self.currentSplitImage.setText(f'Delayed Before Starting:\n {delay_time_left} sec remaining')
- QtTest.QTest.qWait(1)
+ delay_start_time = time()
+ while time() - delay_start_time < (start_image_delay / 1000):
+ delay_time_left = round((start_image_delay / 1000) - (time() - delay_start_time), 1)
+ self.currentSplitImage.setText(f"Delayed Before Starting:\n {delay_time_left} sec remaining")
+ # Email sent to pyqt@riverbankcomputing.com
+ QtTest.QTest.qWait(1) # type: ignore
self.startImageLabel.setText("Start image: started")
split()
@@ -425,26 +480,26 @@ def split():
# update x, y, width, height when spinbox values are changed
def updateX(self):
try:
- self.rect.left = self.xSpinBox.value()
- self.rect.right = self.rect.left + self.widthSpinBox.value()
+ self.selection.left = self.xSpinBox.value()
+ self.selection.right = self.selection.left + self.widthSpinBox.value()
self.checkLiveImage()
except AttributeError:
pass
def updateY(self):
try:
- self.rect.top = self.ySpinBox.value()
- self.rect.bottom = self.rect.top + self.heightSpinBox.value()
+ self.selection.top = self.ySpinBox.value()
+ self.selection.bottom = self.selection.top + self.heightSpinBox.value()
self.checkLiveImage()
except AttributeError:
pass
def updateWidth(self):
- self.rect.right = self.rect.left + self.widthSpinBox.value()
+ self.selection.right = self.selection.left + self.widthSpinBox.value()
self.checkLiveImage()
def updateHeight(self):
- self.rect.bottom = self.rect.top + self.heightSpinBox.value()
+ self.selection.bottom = self.selection.top + self.heightSpinBox.value()
self.checkLiveImage()
# update current split image. needed this to avoid updating it through the hotkey thread.
@@ -453,9 +508,9 @@ def updateSplitImageGUI(self, qImage: QtGui.QImage):
self.currentSplitImage.setPixmap(pix)
def takeScreenshot(self):
- if not self.validateBeforeComparison(check_empty_directory=False):
+ if not validateBeforeComparison(self, check_empty_directory=False):
return
- take_screenshot_filename = '001_SplitImage'
+ take_screenshot_filename = "001_SplitImage"
# check if file exists and rename it if it does
# Below starts the FileNameNumber at #001 up to #999. After that it will go to 1000,
@@ -464,10 +519,10 @@ def takeScreenshot(self):
while os.path.exists(os.path.join(self.split_image_directory, f"{take_screenshot_filename}.png")):
FileNameNumber = (f"{i:03}")
take_screenshot_filename = f"{FileNameNumber}_SplitImage"
- i = i + 1
+ i += 1
# grab screenshot of capture region
- capture = capture_windows.capture_region(self.hwnd, self.rect)
+ capture = capture_region(self.hwnd, self.selection, self.forcePrintWindowCheckBox.isChecked())
capture = cv2.cvtColor(capture, cv2.COLOR_BGRA2BGR)
# save and open image
@@ -477,7 +532,7 @@ def takeScreenshot(self):
# check max FPS button connects here.
# TODO: Average on all images and check for transparency (cv2.COLOR_BGRA2RGB and cv2.IMREAD_UNCHANGED)
def checkFPS(self):
- if not self.validateBeforeComparison():
+ if not validateBeforeComparison(self):
return
split_image_filenames = os.listdir(self.split_image_directory)
@@ -485,61 +540,52 @@ def checkFPS(self):
cv2.imread(os.path.join(self.split_image_directory, image), cv2.IMREAD_COLOR)
for image
in split_image_filenames]
- for image in split_images:
+ for i, image in enumerate(split_images):
if image is None:
- error_messages.imageTypeError(image)
+ error_messages.imageTypeError(split_image_filenames[i])
return
# grab first image in the split image folder
split_image = split_images[0]
split_image = cv2.cvtColor(split_image, cv2.COLOR_BGR2RGB)
- split_image = cv2.resize(split_image, COMPARISON_RESIZE)
+ split_image = cv2.resize(split_image, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
# run 10 iterations of screenshotting capture region + comparison.
count = 0
- t0 = time.time()
+ t0 = time()
while count < 10:
-
- capture = capture_windows.capture_region(self.hwnd, self.rect)
- capture = cv2.resize(capture, COMPARISON_RESIZE)
+ capture = capture_region(self.hwnd, self.selection, self.forcePrintWindowCheckBox.isChecked())
+ capture = cv2.resize(capture, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
capture = cv2.cvtColor(capture, cv2.COLOR_BGRA2RGB)
-
- if self.comparisonmethodComboBox.currentIndex() == 0:
- _ = compare.compare_l2_norm(split_image, capture)
- elif self.comparisonmethodComboBox.currentIndex() == 1:
- _ = compare.compare_histograms(split_image, capture)
- elif self.comparisonmethodComboBox.currentIndex() == 2:
- _ = compare.compare_phash(split_image, capture)
-
- count = count + 1
+ compareImage(self.comparisonmethodComboBox.currentIndex(), split_image, capture)
+ count += 1
# calculate FPS
- t1 = time.time()
+ t1 = time()
fps = str(int(10 / (t1 - t0)))
self.fpsvalueLabel.setText(fps)
def is_current_split_out_of_range(self):
- return self.split_image_number < 0 or self.split_image_number > len(self.split_image_filenames_including_loops) - 1
+ return self.split_image_number < 0 \
+ or self.split_image_number > len(self.split_image_filenames_including_loops) - 1
# undo split button and hotkey connect to here
def undoSplit(self):
# Can't undo until timer is started
# or Undoing past the first image
- if self.startautosplitterButton.text() == 'Start Auto Splitter' or ("Delayed Split") in self.currentSplitImage.text():
- return
-
- if (not self.undosplitButton.isEnabled() and not self.is_auto_controlled) \
+ if self.startautosplitterButton.text() == "Start Auto Splitter" \
+ or "Delayed Split" in self.currentSplitImage.text() \
+ or (not self.undosplitButton.isEnabled() and not self.is_auto_controlled) \
or self.is_current_split_out_of_range():
return
- elif self.groupDummySplitsCheckBox.isChecked():
+ if self.groupDummySplitsCheckBox.isChecked():
for i, group in enumerate(self.split_groups):
if i > 0 and self.split_image_number in group:
self.split_image_number = self.split_groups[i - 1][0]
break
-
else:
- self.split_image_number = self.split_image_number - 1
+ self.split_image_number -= 1
self.updateSplitImage()
@@ -549,10 +595,10 @@ def undoSplit(self):
def skipSplit(self):
# Can't skip or split until timer is started
# or Splitting/skipping when there are no images left
- if self.startautosplitterButton.text() == 'Start Auto Splitter' or ("Delayed Split") in self.currentSplitImage.text():
- return
-
- if (not self.skipsplitButton.isEnabled() and not self.is_auto_controlled) or self.is_current_split_out_of_range():
+ if self.startautosplitterButton.text() == "Start Auto Splitter" \
+ or "Delayed Split" in self.currentSplitImage.text() \
+ or (not self.skipsplitButton.isEnabled() and not self.is_auto_controlled) \
+ or self.is_current_split_out_of_range():
return
if self.groupDummySplitsCheckBox.isChecked():
@@ -561,7 +607,7 @@ def skipSplit(self):
self.split_image_number = group[-1] + 1
break
else:
- self.split_image_number = self.split_image_number + 1
+ self.split_image_number += 1
self.updateSplitImage()
@@ -573,16 +619,13 @@ def skipSplit(self):
def reset(self):
# When the reset button or hotkey is pressed, it will change this text,
# which will trigger in the autoSplitter function, if running, to abort and change GUI.
- self.startautosplitterButton.setText('Start Auto Splitter')
- return
+ self.startautosplitterButton.setText("Start Auto Splitter")
# Functions for the hotkeys to return to the main thread from signals and start their corresponding functions
def startAutoSplitter(self):
- self.hasSentStart = True
-
# If the auto splitter is already running or the button is disabled, don't emit the signal to start it.
- if self.startautosplitterButton.text() == 'Running...' or \
- (not self.startautosplitterButton.isEnabled() and not self.is_auto_controlled):
+ if self.startautosplitterButton.text() == "Running..." \
+ or (not self.startautosplitterButton.isEnabled() and not self.is_auto_controlled):
return
if self.startImageLabel.text() == "Start image: ready" or self.startImageLabel.text() == "Start image: paused":
@@ -603,7 +646,7 @@ def startPause(self):
self.pauseSignal.emit()
def checkForReset(self):
- if self.startautosplitterButton.text() == 'Start Auto Splitter':
+ if self.startautosplitterButton.text() == "Start Auto Splitter":
if self.autostartonresetCheckBox.isChecked():
self.startAutoSplitterSignal.emit()
else:
@@ -612,103 +655,65 @@ def checkForReset(self):
return False
def autoSplitter(self):
- if not self.validateBeforeComparison():
+ if not validateBeforeComparison(self):
+ self.guiChangesOnReset()
return
- # get split image filenames
- self.split_image_filenames = os.listdir(self.split_image_directory)
-
- # Make sure that each of the images follows the guidelines for correct format
- # according to all of the settings selected by the user.
- for image in self.split_image_filenames:
- # Test for image without transparency
- if (cv2.imread(os.path.join(self.split_image_directory, image), cv2.IMREAD_COLOR) is None
- # Test for image with transparency
- and cv2.imread(os.path.join(self.split_image_directory, image), cv2.IMREAD_UNCHANGED) is None):
- # Opencv couldn't open this file as an image, this isn't a correct
- # file format that is supported
- self.guiChangesOnReset()
- error_messages.imageTypeError(image)
- return
-
- # error out if there is a {p} flag but no pause hotkey set and is not auto controlled.
- if (self.pausehotkeyLineEdit.text() == ''
- and split_parser.flags_from_filename(image) & PAUSE_FLAG == PAUSE_FLAG
- and not self.is_auto_controlled):
- self.guiChangesOnReset()
- error_messages.pauseHotkeyError()
- return
-
- if self.splitLineEdit.text() == '' and not self.is_auto_controlled:
+ if not self.splitLineEdit.text() and not self.is_auto_controlled:
self.guiChangesOnReset()
error_messages.splitHotkeyError()
return
- # find reset image then remove it from the list
- self.findResetImage()
-
- # find start_auto_splitter_image and then remove it from the list
- self.removeStartAutoSplitterImage()
-
- # Check that there's only one reset image
- for image in self.split_image_filenames:
+ # get split image filenames
+ self.split_image_filenames = os.listdir(self.split_image_directory)
- if split_parser.is_reset_image(image):
- self.guiChangesOnReset()
- error_messages.multipleKeywordImagesError('reset')
- return
+ split_parser.validate_images_before_parsing(self)
- # Check that there's only one auto_start_autosplitter image
- for image in self.split_image_filenames:
+ # find reset image then remove it from the list
+ self.findResetImage()
- if split_parser.is_start_auto_splitter_image(image):
- self.guiChangesOnReset()
- error_messages.multipleKeywordImagesError('start_auto_splitter')
- return
+ # Find start_auto_splitter_image and then remove it from the list
+ split_parser.removeStartAutoSplitterImage(self.split_image_filenames)
- # If there is no reset hotkey set but a reset image is present, and is not auto controlled, throw an error.
- if self.resetLineEdit.text() == '' and self.reset_image is not None and not self.is_auto_controlled:
- self.guiChangesOnReset()
- error_messages.resetHotkeyError()
- return
+# region TODO I feel this entire region could be simplified
# construct loop amounts for each split image
- self.split_image_loop_amount = []
- for i, image in enumerate(self.split_image_filenames):
- self.split_image_loop_amount.append(split_parser.loop_from_filename(image))
+ split_image_loop_amount = [
+ split_parser.loop_from_filename(image)
+ for image
+ in self.split_image_filenames]
# construct a list of filenames, each filename copied with # of loops it has.
- self.split_image_filenames_including_loops: List[str] = []
+ self.split_image_filenames_including_loops: list[str] = []
for i, filename in enumerate(self.split_image_filenames):
current_loop = 1
- while self.split_image_loop_amount[i] >= current_loop:
+ while split_image_loop_amount[i] >= current_loop:
self.split_image_filenames_including_loops.append(filename)
current_loop = current_loop + 1
# construct a list of corresponding loop number to the filenames
- self.loop_numbers: List[int] = []
+ loop_numbers: list[int] = []
loop_count = 1
for i, filename in enumerate(self.split_image_filenames_including_loops):
if i == 0:
- self.loop_numbers.append(1)
+ loop_numbers.append(1)
else:
- if self.split_image_filenames_including_loops[i] != self.split_image_filenames_including_loops[i-1]:
+ if self.split_image_filenames_including_loops[i] != self.split_image_filenames_including_loops[i - 1]:
loop_count = 1
- self.loop_numbers.append(loop_count)
else:
- loop_count = loop_count + 1
- self.loop_numbers.append(loop_count)
+ loop_count += 1
+ loop_numbers.append(loop_count)
# Merge them
self.split_image_filenames_and_loop_number = [
- (filename, self.loop_numbers[i], self.split_image_filenames_including_loops.count(filename))
+ (filename, loop_numbers[i], self.split_image_filenames_including_loops.count(filename))
for i, filename in enumerate(self.split_image_filenames_including_loops)
]
# construct groups of splits if needed
- self.split_groups = []
+ self.split_groups: list[list[int]] = []
if self.groupDummySplitsCheckBox.isChecked():
- current_group = []
+ current_group: list[int] = []
self.split_groups.append(current_group)
for i, image in enumerate(self.split_image_filenames_including_loops):
@@ -719,43 +724,41 @@ def autoSplitter(self):
current_group = []
self.split_groups.append(current_group)
-
- # construct dummy splits array
- self.dummy_splits_array = []
- for i, image in enumerate(self.split_image_filenames_including_loops):
- if split_parser.flags_from_filename(image) & DUMMY_FLAG == DUMMY_FLAG:
- self.dummy_splits_array.append(True)
- else:
- self.dummy_splits_array.append(False)
+# endregion
self.guiChangesOnStart()
# Initialize a few attributes
self.split_image_number = 0
- self.number_of_split_images = len(self.split_image_filenames_including_loops)
self.waiting_for_split_delay = False
self.split_below_threshold = False
-
- self.run_start_time = time.time()
+ split_time = 0
+ number_of_split_images = len(self.split_image_filenames_including_loops)
+ dummy_splits_array = [
+ split_parser.flags_from_filename(image) & DUMMY_FLAG == DUMMY_FLAG
+ for image
+ in self.split_image_filenames_including_loops]
+ self.run_start_time = time()
+ windowText = win32gui.GetWindowText(self.hwnd)
# First while loop: stays in this loop until all of the split images have been split
- while self.split_image_number < self.number_of_split_images:
+ while self.split_image_number < number_of_split_images:
# Check if we are not waiting for the split delay to send the key press
- if self.waiting_for_split_delay == True:
- time_millis = int(round(time.time() * 1000))
- if time_millis < self.split_time:
- QtWidgets.QApplication.processEvents()
+ if self.waiting_for_split_delay:
+ time_millis = int(round(time() * 1000))
+ if time_millis < split_time:
+ QApplication.processEvents()
continue
self.updateSplitImage()
# second while loop: stays in this loop until similarity threshold is met
# skip loop if we just finished waiting for the split delay and need to press the split key!
- start = time.time()
+ start = time()
while True:
# reset if the set screen region window was closed
- if win32gui.GetWindowText(self.hwnd) == '':
+ if not windowText:
self.reset()
if self.checkForReset():
@@ -765,9 +768,13 @@ def autoSplitter(self):
capture = self.getCaptureForComparison()
if self.shouldCheckResetImage():
- reset_similarity = self.compareImage(self.reset_image, self.reset_mask, capture)
+ reset_similarity = compareImage(
+ self.comparisonmethodComboBox.currentIndex(),
+ self.reset_image,
+ capture,
+ self.reset_mask)
if reset_similarity >= self.reset_image_threshold:
- self.send_command("reset")
+ send_command(self, "reset")
self.reset()
if self.checkForReset():
@@ -779,13 +786,17 @@ def autoSplitter(self):
capture = self.getCaptureForComparison()
# calculate similarity for split image
- self.similarity = self.compareImage(self.split_image, self.image_mask, capture)
+ self.similarity = compareImage(
+ self.comparisonmethodComboBox.currentIndex(),
+ self.split_image,
+ capture,
+ self.image_mask)
# show live similarity if the checkbox is checked
if self.showlivesimilarityCheckBox.isChecked():
self.livesimilarityLabel.setText(str(self.similarity)[:4])
else:
- self.livesimilarityLabel.setText(' ')
+ self.livesimilarityLabel.setText(" ")
# if the similarity becomes higher than highest similarity, set it as such.
if self.similarity > self.highest_similarity:
@@ -795,62 +806,61 @@ def autoSplitter(self):
if self.showhighestsimilarityCheckBox.isChecked():
self.highestsimilarityLabel.setText(str(self.highest_similarity)[:4])
else:
- self.highestsimilarityLabel.setText(' ')
+ self.highestsimilarityLabel.setText(" ")
if not self.is_auto_controlled:
- # if its the last split image or can't skip due to grouped dummy splits, disable the skip split button
- if (self.split_image_number == self.number_of_split_images - 1) or (self.groupDummySplitsCheckBox.isChecked() == True and self.dummy_splits_array[self.split_image_number:].count(False) <= 1):
- self.skipsplitButton.setEnabled(False)
- else:
- self.skipsplitButton.setEnabled(True)
+ # if its the last split image or can't skip due to grouped dummy splits, disable skip split button
+ is_last = self.split_image_number == number_of_split_images - 1 \
+ or (self.groupDummySplitsCheckBox.isChecked()
+ and dummy_splits_array[self.split_image_number:].count(False) <= 1)
+ self.skipsplitButton.setEnabled(not is_last)
# if its the first split image, disable the undo split button
- if self.split_image_number == 0:
- self.undosplitButton.setEnabled(False)
- else:
- self.undosplitButton.setEnabled(True)
+ self.undosplitButton.setEnabled(self.split_image_number != 0)
# if the b flag is set, let similarity go above threshold first,
# then split on similarity below threshold.
# if no b flag, just split when similarity goes above threshold.
if not self.waiting_for_split_delay:
- if self.flags & BELOW_FLAG == BELOW_FLAG and not self.split_below_threshold:
- if self.similarity >= self.similarity_threshold:
+ if self.flags & BELOW_FLAG == BELOW_FLAG:
+ if self.split_below_threshold:
+ if self.similarity < self.similarity_threshold:
+ self.split_below_threshold = False
+ break
+ elif self.similarity >= self.similarity_threshold:
self.split_below_threshold = True
continue
- elif self.flags & BELOW_FLAG == BELOW_FLAG and self.split_below_threshold:
- if self.similarity < self.similarity_threshold:
- self.split_below_threshold = False
- break
elif self.similarity >= self.similarity_threshold:
break
# limit the number of time the comparison runs to reduce cpu usage
- fps_limit = self.fpslimitSpinBox.value()
- time.sleep((1 / fps_limit) - (time.time() - start) % (1 / fps_limit))
- QtWidgets.QApplication.processEvents()
+ frame_interval = 1 / self.fpslimitSpinBox.value()
+ # Email sent to pyqt@riverbankcomputing.com
+ QtTest.QTest.qWait(frame_interval - (time() - start) % frame_interval) # type: ignore
+ QApplication.processEvents()
# comes here when threshold gets met
# We need to make sure that this isn't a dummy split before sending
# the key press.
- if not (self.flags & DUMMY_FLAG == DUMMY_FLAG):
+ if self.flags & DUMMY_FLAG != DUMMY_FLAG:
# If it's a delayed split, check if the delay has passed
# Otherwise calculate the split time for the key press
- if self.split_delay > 0 and self.waiting_for_split_delay == False:
- self.split_time = int(round(time.time() * 1000)) + self.split_delay
+ if self.split_delay > 0 and not self.waiting_for_split_delay:
+ split_time = int(round(time() * 1000) + self.split_delay)
self.waiting_for_split_delay = True
self.undosplitButton.setEnabled(False)
self.skipsplitButton.setEnabled(False)
- self.currentsplitimagefileLabel.setText(' ')
+ self.currentsplitimagefileLabel.setText(" ")
# check for reset while delayed and display a counter of the remaining split delay time
- delay_start_time = time.time()
- while time.time() - delay_start_time < (self.split_delay / 1000):
- delay_time_left = round((self.split_delay / 1000) - (time.time() - delay_start_time), 1)
- self.currentSplitImage.setText(f'Delayed Split: {delay_time_left} sec remaining')
+ delay_start_time = time()
+ split_delay = self.split_delay / 1000
+ while time() - delay_start_time < split_delay:
+ delay_time_left = round(split_delay - (time() - delay_start_time), 1)
+ self.currentSplitImage.setText(f"Delayed Split: {delay_time_left} sec remaining")
# check for reset
- if win32gui.GetWindowText(self.hwnd) == '':
+ if not windowText:
self.reset()
if self.checkForReset():
return
@@ -859,89 +869,90 @@ def autoSplitter(self):
if self.shouldCheckResetImage():
capture = self.getCaptureForComparison()
- reset_similarity = self.compareImage(self.reset_image, self.reset_mask, capture)
+ reset_similarity = compareImage(
+ self.comparisonmethodComboBox.currentIndex(),
+ self.reset_image,
+ capture,
+ self.reset_mask)
if reset_similarity >= self.reset_image_threshold:
- self.send_command("reset")
+ send_command(self, "reset")
self.reset()
continue
-
- QtTest.QTest.qWait(1)
+ # Email sent to pyqt@riverbankcomputing.com
+ QtTest.QTest.qWait(1) # type: ignore
self.waiting_for_split_delay = False
# if {p} flag hit pause key, otherwise hit split hotkey
- if (self.flags & PAUSE_FLAG == PAUSE_FLAG):
- self.send_command("pause")
- else:
- self.send_command("split")
+ send_command(self, "pause" if self.flags & PAUSE_FLAG == PAUSE_FLAG else "split")
# if loop check box is checked and its the last split, go to first split.
# else go to the next split image.
- if self.loopCheckBox.isChecked() and self.split_image_number == self.number_of_split_images - 1:
+ if self.loopCheckBox.isChecked() and self.split_image_number == number_of_split_images - 1:
self.split_image_number = 0
else:
- self.split_image_number = self.split_image_number + 1
+ self.split_image_number += 1
- # set a "pause" split image number. This is done so that it can detect if user hit split/undo split while paused.
+ # Set a "pause" split image number.
+ # This is done so that it can detect if user hit split/undo split while paused.
pause_split_image_number = self.split_image_number
# if its not the last split image, pause for the amount set by the user
- if self.number_of_split_images != self.split_image_number:
+ if number_of_split_images != self.split_image_number:
if not self.is_auto_controlled:
- # if its the last split image and last loop number, disable the skip split button
- if self.split_image_number == self.number_of_split_images - 1 or (self.groupDummySplitsCheckBox.isChecked() == True and self.dummy_splits_array[self.split_image_number:].count(False) <= 1):
- self.skipsplitButton.setEnabled(False)
- else:
- self.skipsplitButton.setEnabled(True)
+ # if its the last split image and last loop number, disable skip split button
+ is_last = self.split_image_number == number_of_split_images - 1 \
+ or (self.groupDummySplitsCheckBox.isChecked()
+ and dummy_splits_array[self.split_image_number:].count(False) <= 1)
+ self.skipsplitButton.setEnabled(not is_last)
# if its the first split image, disable the undo split button
- if self.split_image_number == 0:
- self.undosplitButton.setEnabled(False)
- else:
- self.undosplitButton.setEnabled(True)
-
- QtWidgets.QApplication.processEvents()
-
- # I have a pause loop here so that it can check if the user presses skip split, undo split, or reset here.
- # Also updates the current split image text, counting down the time until the next split image
- if self.pause > 0:
- self.currentsplitimagefileLabel.setText(' ')
- self.imageloopLabel.setText('Image Loop: -')
- pause_start_time = time.time()
- while time.time() - pause_start_time < self.pause:
- pause_time_left = round(self.pause - (time.time() - pause_start_time), 1)
- self.currentSplitImage.setText(f'None (Paused). {pause_time_left} sec remaining')
-
- # check for reset
- if win32gui.GetWindowText(self.hwnd) == '':
- self.reset()
- if self.checkForReset():
- return
-
- # check for skip/undo split:
- if self.split_image_number != pause_split_image_number:
- break
-
- # calculate similarity for reset image
- if self.shouldCheckResetImage():
- capture = self.getCaptureForComparison()
+ self.undosplitButton.setEnabled(self.split_image_number != 0)
+ QApplication.processEvents()
+
+ # A pause loop to check if the user presses skip split, undo split, or reset here.
+ # Also updates the current split image text, counting down the time until the next split image
+ if self.pause > 0:
+ self.currentsplitimagefileLabel.setText(" ")
+ self.imageloopLabel.setText("Image Loop: -")
+ pause_start_time = time()
+ while time() - pause_start_time < self.pause:
+ pause_time_left = round(self.pause - (time() - pause_start_time), 1)
+ self.currentSplitImage.setText(f"None (Paused). {pause_time_left} sec remaining")
+
+ # check for reset
+ if not windowText:
+ self.reset()
+ if self.checkForReset():
+ return
- reset_similarity = self.compareImage(self.reset_image, self.reset_mask, capture)
- if reset_similarity >= self.reset_image_threshold:
- self.send_command("reset")
- self.reset()
- continue
+ # check for skip/undo split:
+ if self.split_image_number != pause_split_image_number:
+ break
- QtTest.QTest.qWait(1)
+ # calculate similarity for reset image
+ if self.shouldCheckResetImage():
+ capture = self.getCaptureForComparison()
+
+ reset_similarity = compareImage(
+ self.comparisonmethodComboBox.currentIndex(),
+ self.reset_image,
+ capture,
+ self.reset_mask)
+ if reset_similarity >= self.reset_image_threshold:
+ send_command(self, "reset")
+ self.reset()
+ continue
+ # Email sent to pyqt@riverbankcomputing.com
+ QtTest.QTest.qWait(1) # type: ignore
# loop breaks to here when the last image splits
self.guiChangesOnReset()
-
def guiChangesOnStart(self):
self.timerStartImage.stop()
- self.startautosplitterButton.setText('Running...')
+ self.startautosplitterButton.setText("Running...")
self.browseButton.setEnabled(False)
self.groupDummySplitsCheckBox.setEnabled(False)
self.startImageReloadButton.setEnabled(False)
@@ -957,17 +968,16 @@ def guiChangesOnStart(self):
self.setundosplithotkeyButton.setEnabled(False)
self.setpausehotkeyButton.setEnabled(False)
- QtWidgets.QApplication.processEvents()
-
+ QApplication.processEvents()
def guiChangesOnReset(self):
- self.startautosplitterButton.setText('Start Auto Splitter')
- self.imageloopLabel.setText('Image Loop: -')
- self.currentSplitImage.setText(' ')
- self.currentsplitimagefileLabel.setText(' ')
- self.livesimilarityLabel.setText(' ')
- self.highestsimilarityLabel.setText(' ')
- self.currentsimilaritythresholdnumberLabel.setText(' ')
+ self.startautosplitterButton.setText("Start Auto Splitter")
+ self.imageloopLabel.setText("Image Loop: -")
+ self.currentSplitImage.setText(" ")
+ self.currentsplitimagefileLabel.setText(" ")
+ self.livesimilarityLabel.setText(" ")
+ self.highestsimilarityLabel.setText(" ")
+ self.currentsimilaritythresholdnumberLabel.setText(" ")
self.browseButton.setEnabled(True)
self.groupDummySplitsCheckBox.setEnabled(True)
self.startImageReloadButton.setEnabled(True)
@@ -983,49 +993,25 @@ def guiChangesOnReset(self):
self.setundosplithotkeyButton.setEnabled(True)
self.setpausehotkeyButton.setEnabled(True)
- QtWidgets.QApplication.processEvents()
+ QApplication.processEvents()
self.loadStartImage(False, False)
-
- def compareImage(self, image, mask, capture):
- if image is None or capture is None:
- return 0.0
- if mask is None:
- if self.comparisonmethodComboBox.currentIndex() == 0:
- return compare.compare_l2_norm(image, capture)
- elif self.comparisonmethodComboBox.currentIndex() == 1:
- return compare.compare_histograms(image, capture)
- elif self.comparisonmethodComboBox.currentIndex() == 2:
- return compare.compare_phash(image, capture)
- else:
- if self.comparisonmethodComboBox.currentIndex() == 0:
- return compare.compare_l2_norm_masked(image, capture, mask)
- elif self.comparisonmethodComboBox.currentIndex() == 1:
- return compare.compare_histograms_masked(image, capture, mask)
- elif self.comparisonmethodComboBox.currentIndex() == 2:
- return compare.compare_phash_masked(image, capture, mask)
- return 0.0
-
def getCaptureForComparison(self):
# grab screenshot of capture region
- capture = capture_windows.capture_region(self.hwnd, self.rect)
- # Capture with nearest neighbor interpolation only if the split image has transparency to support older setups
- if self.imageHasTransparency:
- capture = cv2.resize(capture, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
- else:
- capture = cv2.resize(capture, COMPARISON_RESIZE)
+ capture = capture_region(self.hwnd, self.selection, self.forcePrintWindowCheckBox.isChecked())
+ capture = cv2.resize(capture, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
# convert to BGR
return cv2.cvtColor(capture, cv2.COLOR_BGRA2BGR)
def shouldCheckResetImage(self):
- return self.reset_image is not None and time.time() - self.run_start_time > self.reset_image_pause_time
+ return self.reset_image is not None and time() - self.run_start_time > self.reset_image_pause_time
def findResetImage(self):
self.reset_image = None
self.reset_mask = None
reset_image_file = None
- for i, image in enumerate(self.split_image_filenames):
+ for image in self.split_image_filenames:
if split_parser.is_reset_image(image):
reset_image_file = image
break
@@ -1053,34 +1039,22 @@ def findResetImage(self):
error_messages.imageTypeError(path)
return
# if image has transparency, create a mask
- if compare.checkIfImageHasTransparency(self.reset_image):
+ if checkIfImageHasTransparency(self.reset_image):
self.reset_image = cv2.resize(self.reset_image, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
# Create mask based on resized, nearest neighbor interpolated split image
lower = np.array([0, 0, 0, 1], dtype="uint8")
- upper = np.array([255, 255, 255, 255], dtype="uint8")
+ upper = np.array([MAXBYTE, MAXBYTE, MAXBYTE, MAXBYTE], dtype="uint8")
self.reset_mask = cv2.inRange(self.reset_image, lower, upper)
# set split image as BGR
self.reset_image = cv2.cvtColor(self.reset_image, cv2.COLOR_BGRA2BGR)
- # otherwise, open image normally. Capture with nearest neighbor interpolation only if the split image has transparency to support older setups
+ # otherwise, open image normally.
else:
self.reset_image = cv2.imread(path, cv2.IMREAD_COLOR)
- self.reset_image = cv2.resize(self.reset_image, COMPARISON_RESIZE)
-
- def removeStartAutoSplitterImage(self):
- start_auto_splitter_image_file = None
- for _, image in enumerate(self.split_image_filenames):
- if split_parser.is_start_auto_splitter_image(image):
- start_auto_splitter_image_file = image
- break
-
- if start_auto_splitter_image_file is None:
- return
-
- self.split_image_filenames.remove(start_auto_splitter_image_file)
+ self.reset_image = cv2.resize(self.reset_image, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
- def updateSplitImage(self, custom_image_file: str = '', from_start_image: bool = False):
+ def updateSplitImage(self, custom_image_file: str = "", from_start_image: bool = False):
# Splitting/skipping when there are no images left or Undoing past the first image
# Start image is expected to be out of range (index 0 of 0-length array)
if "START_AUTO_SPLITTER" not in custom_image_file.upper() and self.is_current_split_out_of_range():
@@ -1098,35 +1072,34 @@ def updateSplitImage(self, custom_image_file: str = '', from_start_image: bool =
if self.split_image is None:
error_messages.imageTypeError(self.split_image_path)
return
- self.imageHasTransparency = compare.checkIfImageHasTransparency(self.split_image)
+ self.imageHasTransparency = checkIfImageHasTransparency(self.split_image)
# if image has transparency, create a mask
if self.imageHasTransparency:
split_image_display = copy(self.split_image)
# Transform transparency into UI's gray BG color
transparent_mask = split_image_display[:, :, 3] == 0
- split_image_display[:, :, 3] == 0
- split_image_display[transparent_mask] = [240, 240, 240, 255]
+ split_image_display[transparent_mask] = [240, 240, 240, MAXBYTE]
split_image_display = cv2.cvtColor(split_image_display, cv2.COLOR_BGRA2RGB)
self.split_image = cv2.resize(self.split_image, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
# Create mask based on resized, nearest neighbor interpolated split image
lower = np.array([0, 0, 0, 1], dtype="uint8")
- upper = np.array([255, 255, 255, 255], dtype="uint8")
+ upper = np.array([MAXBYTE, MAXBYTE, MAXBYTE, MAXBYTE], dtype="uint8")
self.image_mask = cv2.inRange(self.split_image, lower, upper)
# set split image as BGR
self.split_image = cv2.cvtColor(self.split_image, cv2.COLOR_BGRA2BGR)
- # otherwise, open image normally. don't interpolate nearest neighbor here so setups before 1.2.0 still work.
+ # otherwise, open image normally.
else:
self.split_image = cv2.imread(self.split_image_path, cv2.IMREAD_COLOR)
split_image_display = cv2.cvtColor(copy(self.split_image), cv2.COLOR_BGR2RGB)
- self.split_image = cv2.resize(self.split_image, COMPARISON_RESIZE)
+ self.split_image = cv2.resize(self.split_image, COMPARISON_RESIZE, interpolation=cv2.INTER_NEAREST)
self.image_mask = None
split_image_display = cv2.resize(split_image_display, DISPLAY_RESIZE)
# Set current split image in UI
- qImage = QtGui.QImage(split_image_display,
+ qImage = QtGui.QImage(cast(bytes, split_image_display),
split_image_display.shape[1],
split_image_display.shape[0],
split_image_display.shape[1] * 3,
@@ -1143,7 +1116,7 @@ def updateSplitImage(self, custom_image_file: str = '', from_start_image: bool =
self.similarity_threshold = self.similaritythresholdDoubleSpinBox.value() \
if threshold_from_filename is None \
else threshold_from_filename
- self.currentsimilaritythresholdnumberLabel.setText("{:.2f}".format(self.similarity_threshold))
+ self.currentsimilaritythresholdnumberLabel.setText(f"{self.similarity_threshold:.2f}")
# Get delay for split, if any
self.split_delay = split_parser.delay_from_filename(split_image_file)
@@ -1162,10 +1135,10 @@ def updateSplitImage(self, custom_image_file: str = '', from_start_image: bool =
self.highest_similarity = 0.001
# exit safely when closing the window
- def closeEvent(self, event: QtGui.QCloseEvent = None):
- def exit():
- if event is not None:
- event.accept()
+ def closeEvent(self, a0: Optional[QtGui.QCloseEvent] = None):
+ def exitProgram():
+ if a0 is not None:
+ a0.accept()
if self.is_auto_controlled:
self.update_auto_control.terminate()
# stop main thread (which is probably blocked reading input) via an interrupt signal
@@ -1176,50 +1149,40 @@ def exit():
# Simulates LiveSplit quitting without asking. See "TODO" at update_auto_control Worker
# This also more gracefully exits LiveSplit
# Users can still manually save their settings
- if event is None:
- exit()
+ if a0 is None:
+ exitProgram()
- if self.haveSettingsChanged():
- # give a different warning if there was never a settings file that was loaded successfully, and save as instead of save.
- msgBox = QtWidgets.QMessageBox
+ if settings.haveSettingsChanged(self):
+ # Give a different warning if there was never a settings file that was loaded successfully,
+ # and "save as" instead of "save".
settings_file_name = "Untitled" \
if self.last_successfully_loaded_settings_file_path is None \
else os.path.basename(self.last_successfully_loaded_settings_file_path)
warning_message = f"Do you want to save changes made to settings file {settings_file_name}?"
- warning = msgBox.warning(
+ warning = QMessageBox.warning(
self,
"AutoSplit",
warning_message,
- msgBox.StandardButton.Yes | msgBox.StandardButton.No | msgBox.StandardButton.Cancel)
+ QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No | QMessageBox.StandardButton.Cancel)
- if warning == msgBox.StandardButton.Yes:
+ if warning is QMessageBox.StandardButton.Yes:
# TODO: Don't close if user cancelled the save
self.saveSettingsAs()
- exit()
- if warning == msgBox.StandardButton.No:
- exit()
- if warning == msgBox.StandardButton.Cancel:
- event.ignore()
+ exitProgram()
+ if warning is QMessageBox.StandardButton.No:
+ exitProgram()
+ if warning is QMessageBox.StandardButton.Cancel:
+ a0.ignore()
else:
- exit()
-
-
-def excepthook(exception: BaseException, main_window: AutoSplit):
- # Catch Keyboard Interrupts for a clean close
- if type(exception) is KeyboardInterrupt:
- sys.exit(0)
- main_window.showErrorSignal.emit(lambda: error_messages.exceptionTraceback(
- "AutoSplit encountered an unhandled exception and will try to recover, "
- f"however, there is no guarantee everything will work properly. {CREATE_NEW_ISSUE_MESSAGE}",
- exception)) \
+ exitProgram()
def main():
# Call to QApplication outside the try-except so we can show error messages
- app = QtWidgets.QApplication(sys.argv)
+ app = QApplication(sys.argv)
try:
- app.setWindowIcon(QtGui.QIcon(':/resources/icon.ico'))
+ app.setWindowIcon(QtGui.QIcon(":/resources/icon.ico"))
AutoSplit()
# Kickoff the event loop every so often so we can handle KeyboardInterrupt (^C)
@@ -1228,7 +1191,7 @@ def main():
timer.start(500)
exit_code = app.exec()
- except Exception as exception:
+ except Exception as exception: # pylint: disable=broad-except
message = f"AutoSplit encountered an unrecoverable exception and will now close. {CREATE_NEW_ISSUE_MESSAGE}"
# Print error to console if not running in executable
if FROZEN:
@@ -1239,10 +1202,10 @@ def main():
sys.exit(1)
# Catch Keyboard Interrupts for a clean close
- signal.signal(signal.SIGINT, lambda code, _: sys.exit(code))
+ signal.signal(signal.SIGINT, lambda code, _: sys.exit(code))
sys.exit(exit_code)
-if __name__ == '__main__':
+if __name__ == "__main__":
main()
diff --git a/src/about.py b/src/about.py
deleted file mode 100644
index a4303bca..00000000
--- a/src/about.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# Form implementation generated from reading ui file '.\res\about.ui'
-#
-# Created by: PyQt6 UI code generator 6.1.0
-#
-# WARNING: Any manual changes made to this file will be lost when pyuic6 is
-# run again. Do not edit this file unless you know what you are doing.
-
-
-from PyQt6 import QtCore, QtGui, QtWidgets
-
-
-class Ui_aboutAutoSplitWidget(object):
- def setupUi(self, aboutAutoSplitWidget):
- aboutAutoSplitWidget.setObjectName("aboutAutoSplitWidget")
- aboutAutoSplitWidget.resize(264, 250)
- aboutAutoSplitWidget.setMinimumSize(QtCore.QSize(264, 250))
- aboutAutoSplitWidget.setMaximumSize(QtCore.QSize(264, 250))
- font = QtGui.QFont()
- font.setPointSize(9)
- aboutAutoSplitWidget.setFont(font)
- icon = QtGui.QIcon()
- icon.addPixmap(QtGui.QPixmap(":/resources/icon.ico"), QtGui.QIcon.Mode.Normal, QtGui.QIcon.State.Off)
- aboutAutoSplitWidget.setWindowIcon(icon)
- self.okButton = QtWidgets.QPushButton(aboutAutoSplitWidget)
- self.okButton.setGeometry(QtCore.QRect(180, 220, 75, 24))
- self.okButton.setObjectName("okButton")
- self.createdbyLabel = QtWidgets.QLabel(aboutAutoSplitWidget)
- self.createdbyLabel.setGeometry(QtCore.QRect(10, 44, 161, 32))
- self.createdbyLabel.setObjectName("createdbyLabel")
- self.versionLabel = QtWidgets.QLabel(aboutAutoSplitWidget)
- self.versionLabel.setGeometry(QtCore.QRect(10, 21, 161, 16))
- self.versionLabel.setObjectName("versionLabel")
- self.donatetextLabel = QtWidgets.QLabel(aboutAutoSplitWidget)
- self.donatetextLabel.setGeometry(QtCore.QRect(30, 95, 204, 32))
- self.donatetextLabel.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
- self.donatetextLabel.setObjectName("donatetextLabel")
- self.donatebuttonLabel = QtWidgets.QLabel(aboutAutoSplitWidget)
- self.donatebuttonLabel.setGeometry(QtCore.QRect(60, 150, 147, 47))
- self.donatebuttonLabel.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
- self.donatebuttonLabel.setObjectName("donatebuttonLabel")
- self.iconLabel = QtWidgets.QLabel(aboutAutoSplitWidget)
- self.iconLabel.setGeometry(QtCore.QRect(190, 17, 62, 71))
- self.iconLabel.setObjectName("iconLabel")
-
- self.retranslateUi(aboutAutoSplitWidget)
- self.okButton.clicked.connect(aboutAutoSplitWidget.close)
- QtCore.QMetaObject.connectSlotsByName(aboutAutoSplitWidget)
-
- def retranslateUi(self, aboutAutoSplitWidget):
- _translate = QtCore.QCoreApplication.translate
- aboutAutoSplitWidget.setWindowTitle(_translate("aboutAutoSplitWidget", "About AutoSplit"))
- self.okButton.setText(_translate("aboutAutoSplitWidget", "OK"))
- self.createdbyLabel.setText(_translate("aboutAutoSplitWidget", "Created by Toufool and Faschz
Maintained by Avasam
"))
- self.versionLabel.setText(_translate("aboutAutoSplitWidget", "Version: "))
- self.donatetextLabel.setText(_translate("aboutAutoSplitWidget", "If you enjoy using this program, please\n"
-"consider donating. Thank you!"))
- self.donatebuttonLabel.setText(_translate("aboutAutoSplitWidget", "![](\":/resources/btn_donateCC_LG.png\"/)