561 lines
22 KiB
Python
561 lines
22 KiB
Python
# This file is a part of Lector, a Qt based ebook reader
|
|
# Copyright (C) 2017-2019 BasioMeusPuga
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
# TODO
|
|
# Get Cancel working with the file system model
|
|
|
|
import os
|
|
import copy
|
|
import logging
|
|
import pathlib
|
|
|
|
from PyQt5 import QtWidgets, QtCore, QtGui
|
|
|
|
from lector import database
|
|
from lector.annotations import AnnotationsUI
|
|
from lector.models import MostExcellentFileSystemModel
|
|
from lector.threaded import BackGroundBookSearch, BackGroundBookAddition
|
|
from lector.resources import settingswindow
|
|
from lector.settings import Settings
|
|
from lector.logger import logger_filename, VERSION
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class SettingsUI(QtWidgets.QDialog, settingswindow.Ui_Dialog):
|
|
def __init__(self, parent=None):
|
|
super(SettingsUI, self).__init__()
|
|
self.setupUi(self)
|
|
self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)
|
|
self._translate = QtCore.QCoreApplication.translate
|
|
|
|
self.main_window = parent
|
|
self.database_path = self.main_window.database_path
|
|
self.image_factory = self.main_window.QImageFactory
|
|
|
|
# The annotation dialog will use the settings dialog as its parent
|
|
self.annotationsDialog = AnnotationsUI(self)
|
|
|
|
self.resize(self.main_window.settings['settings_dialog_size'])
|
|
self.move(self.main_window.settings['settings_dialog_position'])
|
|
|
|
install_dir = os.path.realpath(__file__)
|
|
install_dir = pathlib.Path(install_dir).parents[1]
|
|
aboutfile_path = os.path.join(install_dir, 'lector', 'resources', 'about.html')
|
|
with open(aboutfile_path) as about_html:
|
|
html = about_html.readlines()
|
|
html.insert(
|
|
8, f'<h3 style="text-align: center;">v{VERSION}</h3>\n')
|
|
self.aboutBox.setHtml(''.join(html))
|
|
|
|
self.paths = None
|
|
self.thread = None
|
|
self.filesystemModel = None
|
|
self.tag_data_copy = None
|
|
|
|
english_string = self._translate('SettingsUI', 'English')
|
|
spanish_string = self._translate('SettingsUI', 'Spanish')
|
|
hindi_string = self._translate('SettingsUI', 'Hindi')
|
|
languages = [english_string, spanish_string, hindi_string]
|
|
|
|
self.languageBox.addItems(languages)
|
|
current_language = self.main_window.settings['dictionary_language']
|
|
if current_language == 'en':
|
|
self.languageBox.setCurrentIndex(0)
|
|
elif current_language == 'es':
|
|
self.languageBox.setCurrentIndex(1)
|
|
else:
|
|
self.languageBox.setCurrentIndex(2)
|
|
self.languageBox.activated.connect(self.change_dictionary_language)
|
|
|
|
self.okButton.setToolTip(
|
|
self._translate('SettingsUI', 'Save changes and start library scan'))
|
|
self.okButton.clicked.connect(self.start_library_scan)
|
|
self.cancelButton.clicked.connect(self.cancel_pressed)
|
|
|
|
# Radio buttons
|
|
if self.main_window.settings['icon_theme'] == 'DarkIcons':
|
|
self.darkIconsRadio.setChecked(True)
|
|
else:
|
|
self.lightIconsRadio.setChecked(True)
|
|
self.darkIconsRadio.clicked.connect(self.change_icon_theme)
|
|
self.lightIconsRadio.clicked.connect(self.change_icon_theme)
|
|
|
|
# Check boxes
|
|
self.autoTags.setChecked(self.main_window.settings['auto_tags'])
|
|
self.coverShadows.setChecked(self.main_window.settings['cover_shadows'])
|
|
self.refreshLibrary.setChecked(self.main_window.settings['scan_library'])
|
|
self.fileRemember.setChecked(self.main_window.settings['remember_files'])
|
|
self.performCulling.setChecked(self.main_window.settings['perform_culling'])
|
|
self.cachingEnabled.setChecked(self.main_window.settings['caching_enabled'])
|
|
self.hideScrollBars.setChecked(self.main_window.settings['hide_scrollbars'])
|
|
self.attenuateTitles.setChecked(self.main_window.settings['attenuate_titles'])
|
|
self.autoCover.setChecked(self.main_window.settings['auto_cover'])
|
|
self.scrollSpeedSlider.setValue(self.main_window.settings['scroll_speed'])
|
|
self.readAtPercent.setValue(self.main_window.settings['consider_read_at'])
|
|
self.smallIncrementBox.setValue(self.main_window.settings['small_increment'])
|
|
self.largeIncrementBox.setValue(self.main_window.settings['large_increment'])
|
|
|
|
self.autoTags.clicked.connect(self.manage_checkboxes)
|
|
self.coverShadows.clicked.connect(self.manage_checkboxes)
|
|
self.refreshLibrary.clicked.connect(self.manage_checkboxes)
|
|
self.fileRemember.clicked.connect(self.manage_checkboxes)
|
|
self.performCulling.clicked.connect(self.manage_checkboxes)
|
|
self.cachingEnabled.clicked.connect(self.manage_checkboxes)
|
|
self.hideScrollBars.clicked.connect(self.manage_checkboxes)
|
|
self.attenuateTitles.clicked.connect(self.manage_checkboxes)
|
|
self.autoCover.clicked.connect(self.manage_checkboxes)
|
|
self.scrollSpeedSlider.valueChanged.connect(self.change_scroll_speed)
|
|
self.readAtPercent.valueChanged.connect(self.change_read_at)
|
|
self.smallIncrementBox.valueChanged.connect(self.change_increment)
|
|
self.largeIncrementBox.valueChanged.connect(self.change_increment)
|
|
|
|
# Generate the QStandardItemModel for the listView
|
|
self.listModel = QtGui.QStandardItemModel(self.listView)
|
|
|
|
library_string = self._translate('SettingsUI', 'Library')
|
|
switches_string = self._translate('SettingsUI', 'Switches')
|
|
annotations_string = self._translate('SettingsUI', 'Annotations')
|
|
about_string = self._translate('SettingsUI', 'About')
|
|
list_options = [
|
|
library_string, switches_string, annotations_string, about_string]
|
|
|
|
icon_dict = {
|
|
0: 'view-readermode',
|
|
1: 'switches',
|
|
2: 'annotate',
|
|
3: 'about'}
|
|
|
|
for count, i in enumerate(list_options):
|
|
item = QtGui.QStandardItem()
|
|
item.setText(i)
|
|
this_icon = icon_dict[count]
|
|
item.setIcon(
|
|
self.main_window.QImageFactory.get_image(this_icon))
|
|
self.listModel.appendRow(item)
|
|
self.listView.setModel(self.listModel)
|
|
|
|
# Custom signal to account for page changes
|
|
self.listView.newIndexSignal.connect(self.list_index_changed)
|
|
|
|
# Annotation related buttons
|
|
# Icon names
|
|
self.newAnnotation.setIcon(self.image_factory.get_image('add'))
|
|
self.deleteAnnotation.setIcon(self.image_factory.get_image('remove'))
|
|
self.editAnnotation.setIcon(self.image_factory.get_image('edit-rename'))
|
|
self.moveUp.setIcon(self.image_factory.get_image('arrow-up'))
|
|
self.moveDown.setIcon(self.image_factory.get_image('arrow-down'))
|
|
|
|
# Icon sizes
|
|
self.newAnnotation.setIconSize(QtCore.QSize(24, 24))
|
|
self.deleteAnnotation.setIconSize(QtCore.QSize(24, 24))
|
|
self.editAnnotation.setIconSize(QtCore.QSize(24, 24))
|
|
self.moveUp.setIconSize(QtCore.QSize(24, 24))
|
|
self.moveDown.setIconSize(QtCore.QSize(24, 24))
|
|
|
|
self.annotationsList.clicked.connect(self.load_annotation)
|
|
self.annotationsList.doubleClicked.connect(self.editAnnotation.click)
|
|
self.newAnnotation.clicked.connect(self.add_annotation)
|
|
self.deleteAnnotation.clicked.connect(self.delete_annotation)
|
|
self.editAnnotation.clicked.connect(self.load_annotation)
|
|
self.moveUp.clicked.connect(self.move_annotation)
|
|
self.moveDown.clicked.connect(self.move_annotation)
|
|
|
|
# Generate annotation settings
|
|
self.annotationModel = QtGui.QStandardItemModel()
|
|
self.generate_annotations()
|
|
|
|
# Generate the filesystem treeView
|
|
self.generate_tree()
|
|
|
|
# About... About
|
|
self.aboutTabWidget.setDocumentMode(True)
|
|
self.aboutTabWidget.setContentsMargins(0, 0, 0, 0)
|
|
self.logBox.setReadOnly(True)
|
|
|
|
# About buttons
|
|
self.resetButton.clicked.connect(self.delete_database)
|
|
self.clearLogButton.clicked.connect(self.clear_log)
|
|
|
|
# Hide the image annotation tab
|
|
# TODO
|
|
# Maybe get off your lazy ass and write something for this
|
|
self.tabWidget.setContentsMargins(0, 0, 0, 0)
|
|
self.tabWidget.tabBar().setVisible(False)
|
|
|
|
def list_index_changed(self, index):
|
|
switch_to = index.row()
|
|
self.stackedWidget.setCurrentIndex(switch_to)
|
|
|
|
valid_buttons = {
|
|
0: (self.okButton,),
|
|
3: (self.resetButton, self.clearLogButton),}
|
|
|
|
for i in valid_buttons:
|
|
if i == switch_to:
|
|
for j in valid_buttons[i]:
|
|
j.setVisible(True)
|
|
else:
|
|
for j in valid_buttons[i]:
|
|
j.setVisible(False)
|
|
|
|
def generate_tree(self):
|
|
# Fetch all directories in the database
|
|
paths = database.DatabaseFunctions(
|
|
self.database_path).fetch_data(
|
|
('Path', 'Name', 'Tags', 'CheckState'),
|
|
'directories',
|
|
{'Path': ''},
|
|
'LIKE')
|
|
|
|
self.main_window.generate_library_filter_menu(paths)
|
|
directory_data = {}
|
|
if not paths:
|
|
logger.warning('No book paths saved')
|
|
else:
|
|
# Convert to the dictionary format that is
|
|
# to be fed into the QFileSystemModel
|
|
for i in paths:
|
|
directory_data[i[0]] = {
|
|
'name': i[1],
|
|
'tags': i[2],
|
|
'check_state': i[3]}
|
|
|
|
self.filesystemModel = MostExcellentFileSystemModel(directory_data)
|
|
self.filesystemModel.setFilter(
|
|
QtCore.QDir.NoDotAndDotDot | QtCore.QDir.Dirs)
|
|
self.treeView.setModel(self.filesystemModel)
|
|
|
|
# TODO
|
|
# This here might break on them pestilent non unixy OSes
|
|
# Check and see
|
|
|
|
root_directory = QtCore.QDir().rootPath()
|
|
self.treeView.setRootIndex(
|
|
self.filesystemModel.setRootPath(root_directory))
|
|
|
|
# Set the treeView and QFileSystemModel to its desired state
|
|
selected_paths = [
|
|
i for i in directory_data
|
|
if directory_data[i]['check_state'] == QtCore.Qt.Checked]
|
|
expand_paths = set()
|
|
for i in selected_paths:
|
|
|
|
# Recursively grind down parent paths for expansion
|
|
this_path = i
|
|
while True:
|
|
parent_path = os.path.dirname(this_path)
|
|
if parent_path == this_path:
|
|
break
|
|
expand_paths.add(parent_path)
|
|
this_path = parent_path
|
|
|
|
# Expand all the parent paths derived from the selected path
|
|
if root_directory in expand_paths:
|
|
expand_paths.remove(root_directory)
|
|
|
|
for i in expand_paths:
|
|
this_index = self.filesystemModel.index(i)
|
|
self.treeView.expand(this_index)
|
|
|
|
header_sizes = self.main_window.settings['settings_dialog_headers']
|
|
if header_sizes:
|
|
for count, i in enumerate((0, 4)):
|
|
self.treeView.setColumnWidth(i, int(header_sizes[count]))
|
|
|
|
# TODO
|
|
# Set a QSortFilterProxy model on top of the existing QFileSystem model
|
|
# self.filesystem_proxy_model = FileSystemProxyModel()
|
|
# self.filesystem_proxy_model.setSourceModel(self.filesystem_model)
|
|
# self.treeView.setModel(self.filesystem_proxy_model)
|
|
|
|
for i in range(1, 4):
|
|
self.treeView.hideColumn(i)
|
|
|
|
def start_library_scan(self):
|
|
self.hide()
|
|
|
|
data_pairs = []
|
|
for i in self.filesystemModel.tag_data.items():
|
|
data_pairs.append([
|
|
i[0], i[1]['name'], i[1]['tags'], i[1]['check_state']
|
|
])
|
|
|
|
database.DatabaseFunctions(
|
|
self.database_path).set_library_paths(data_pairs)
|
|
|
|
if not data_pairs:
|
|
logger.error('Can\'t scan - No book paths saved')
|
|
try:
|
|
if self.sender().objectName() == 'reloadLibrary':
|
|
self.show()
|
|
treeViewIndex = self.listModel.index(0, 0)
|
|
self.listView.setCurrentIndex(treeViewIndex)
|
|
return
|
|
except AttributeError:
|
|
pass
|
|
|
|
database.DatabaseFunctions(
|
|
self.database_path).delete_from_database('*', '*')
|
|
|
|
self.main_window.lib_ref.generate_model('build')
|
|
self.main_window.lib_ref.generate_proxymodels()
|
|
self.main_window.generate_library_filter_menu()
|
|
|
|
return
|
|
|
|
# Update the main window library filter menu
|
|
self.main_window.generate_library_filter_menu(data_pairs)
|
|
self.main_window.set_library_filter()
|
|
|
|
# Disallow rechecking until the first check completes
|
|
self.okButton.setEnabled(False)
|
|
self.main_window.libraryToolBar.reloadLibraryButton.setEnabled(False)
|
|
self.okButton.setToolTip(
|
|
self._translate('SettingsUI', 'Library scan in progress...'))
|
|
|
|
# Traverse directories looking for files
|
|
self.main_window.statusMessage.setText(
|
|
self._translate('SettingsUI', 'Checking library folders'))
|
|
self.thread = BackGroundBookSearch(data_pairs)
|
|
self.thread.finished.connect(self.finished_iterating)
|
|
self.thread.start()
|
|
|
|
def finished_iterating(self):
|
|
# The books the search thread has found
|
|
# are now in self.thread.valid_files
|
|
if not self.thread.valid_files:
|
|
self.main_window.move_on()
|
|
return
|
|
|
|
# Hey, messaging is important, okay?
|
|
self.main_window.statusBar.setVisible(True)
|
|
self.main_window.sorterProgress.setVisible(True)
|
|
self.main_window.statusMessage.setText(
|
|
self._translate('SettingsUI', 'Parsing files'))
|
|
|
|
# We now create a new thread to put those files into the database
|
|
self.thread = BackGroundBookAddition(
|
|
self.thread.valid_files, self.database_path, 'automatic', self.main_window)
|
|
self.thread.finished.connect(
|
|
lambda: self.main_window.move_on(self.thread.errors))
|
|
self.thread.start()
|
|
|
|
def cancel_pressed(self):
|
|
self.filesystemModel.tag_data = copy.deepcopy(self.tag_data_copy)
|
|
self.hide()
|
|
|
|
def hideEvent(self, event):
|
|
self.no_more_settings()
|
|
event.accept()
|
|
|
|
def showEvent(self, event):
|
|
# Load log into the plainTextEdit
|
|
with open(logger_filename) as infile:
|
|
log_text = infile.read()
|
|
self.logBox.setPlainText(log_text)
|
|
# Annotation preview
|
|
self.format_preview()
|
|
# Make copy of tags in case of a nope.jpg
|
|
self.tag_data_copy = copy.deepcopy(self.filesystemModel.tag_data)
|
|
|
|
event.accept()
|
|
|
|
def no_more_settings(self):
|
|
self.main_window.libraryToolBar.settingsButton.setChecked(False)
|
|
self.gather_annotations()
|
|
Settings(self.main_window).save_settings()
|
|
Settings(self.main_window).read_settings()
|
|
self.main_window.settings['last_open_tab'] = None # Needed to allow focus change
|
|
# to newly opened book
|
|
self.resizeEvent()
|
|
|
|
def resizeEvent(self, event=None):
|
|
self.main_window.settings['settings_dialog_size'] = self.size()
|
|
self.main_window.settings['settings_dialog_position'] = self.pos()
|
|
table_headers = []
|
|
for i in [0, 4]:
|
|
table_headers.append(self.treeView.columnWidth(i))
|
|
self.main_window.settings['settings_dialog_headers'] = table_headers
|
|
|
|
def change_icon_theme(self):
|
|
if self.sender() == self.darkIconsRadio:
|
|
self.main_window.settings['icon_theme'] = 'DarkIcons'
|
|
else:
|
|
self.main_window.settings['icon_theme'] = 'LightIcons'
|
|
|
|
def change_dictionary_language(self, event):
|
|
language_dict = {
|
|
0: 'en',
|
|
1: 'es',
|
|
2: 'hi'}
|
|
self.main_window.settings[
|
|
'dictionary_language'] = language_dict[self.languageBox.currentIndex()]
|
|
|
|
def change_scroll_speed(self, event=None):
|
|
self.main_window.settings['scroll_speed'] = self.scrollSpeedSlider.value()
|
|
|
|
def change_read_at(self, event=None):
|
|
self.main_window.settings['consider_read_at'] = self.readAtPercent.value()
|
|
|
|
def change_increment(self, event=None):
|
|
self.main_window.settings['small_increment'] = self.smallIncrementBox.value()
|
|
self.main_window.settings['large_increment'] = self.largeIncrementBox.value()
|
|
|
|
def manage_checkboxes(self, event=None):
|
|
sender = self.sender().objectName()
|
|
|
|
sender_dict = {
|
|
'coverShadows': 'cover_shadows',
|
|
'autoTags': 'auto_tags',
|
|
'refreshLibrary': 'scan_library',
|
|
'fileRemember': 'remember_files',
|
|
'performCulling': 'perform_culling',
|
|
'cachingEnabled': 'caching_enabled',
|
|
'hideScrollBars': 'hide_scrollbars',
|
|
'attenuateTitles': 'attenuate_titles',
|
|
'autoCover': 'auto_cover'}
|
|
|
|
self.main_window.settings[
|
|
sender_dict[sender]] = not self.main_window.settings[sender_dict[sender]]
|
|
|
|
if not self.performCulling.isChecked():
|
|
self.main_window.cover_functions.load_all_covers()
|
|
|
|
def generate_annotations(self):
|
|
saved_annotations = self.main_window.settings['annotations']
|
|
|
|
for i in saved_annotations:
|
|
item = QtGui.QStandardItem()
|
|
item.setText(i['name'])
|
|
item.setData(i, QtCore.Qt.UserRole)
|
|
self.annotationModel.appendRow(item)
|
|
|
|
self.annotationsList.setModel(self.annotationModel)
|
|
|
|
def format_preview(self):
|
|
# Needed to clear the preview of annotation ickiness
|
|
cursor = QtGui.QTextCursor()
|
|
self.previewView.setTextCursor(cursor)
|
|
|
|
self.previewView.setText('Vidistine nuper imagines moventes bonas?')
|
|
profile_index = self.main_window.bookToolBar.profileBox.currentIndex()
|
|
current_profile = self.main_window.bookToolBar.profileBox.itemData(
|
|
profile_index, QtCore.Qt.UserRole)
|
|
|
|
if not current_profile:
|
|
return
|
|
|
|
font = current_profile['font']
|
|
self.foreground = current_profile['foreground']
|
|
background = current_profile['background']
|
|
font_size = current_profile['font_size']
|
|
|
|
self.previewView.setStyleSheet(
|
|
"QTextEdit {{font-family: {0}; font-size: {1}px; color: {2}; background-color: {3}}}".format(
|
|
font, font_size, self.foreground.name(), background.name()))
|
|
|
|
block_format = QtGui.QTextBlockFormat()
|
|
block_format.setAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignHCenter)
|
|
|
|
cursor = self.previewView.textCursor()
|
|
while True:
|
|
old_position = cursor.position()
|
|
cursor.mergeBlockFormat(block_format)
|
|
cursor.movePosition(QtGui.QTextCursor.NextBlock, 0, 1)
|
|
new_position = cursor.position()
|
|
if old_position == new_position:
|
|
break
|
|
|
|
def add_annotation(self):
|
|
self.annotationsDialog.show_dialog('add')
|
|
|
|
def delete_annotation(self):
|
|
selected_index = self.annotationsList.currentIndex()
|
|
if not selected_index.isValid():
|
|
return
|
|
|
|
self.annotationModel.removeRow(
|
|
self.annotationsList.currentIndex().row())
|
|
self.format_preview()
|
|
self.annotationsList.clearSelection()
|
|
|
|
def load_annotation(self):
|
|
selected_index = self.annotationsList.currentIndex()
|
|
if not selected_index.isValid():
|
|
return
|
|
|
|
if self.sender() == self.annotationsList:
|
|
self.annotationsDialog.show_dialog('preview', selected_index)
|
|
|
|
elif self.sender() == self.editAnnotation:
|
|
self.annotationsDialog.show_dialog('edit', selected_index)
|
|
|
|
def move_annotation(self):
|
|
current_row = self.annotationsList.currentIndex().row()
|
|
|
|
if self.sender() == self.moveUp:
|
|
new_row = current_row - 1
|
|
if new_row < 0:
|
|
return
|
|
|
|
elif self.sender() == self.moveDown:
|
|
new_row = current_row + 1
|
|
if new_row == self.annotationModel.rowCount():
|
|
return
|
|
|
|
row_out = self.annotationModel.takeRow(current_row)
|
|
self.annotationModel.insertRow(new_row, row_out)
|
|
new_index = self.annotationModel.index(new_row, 0)
|
|
|
|
self.annotationsList.setCurrentIndex(new_index)
|
|
|
|
def gather_annotations(self):
|
|
annotations_out = []
|
|
for i in range(self.annotationModel.rowCount()):
|
|
annotation_item = self.annotationModel.item(i, 0)
|
|
annotation_data = annotation_item.data(QtCore.Qt.UserRole)
|
|
annotations_out.append(annotation_data)
|
|
|
|
self.main_window.settings['annotations'] = annotations_out
|
|
|
|
def delete_database(self):
|
|
def ifcontinue(box_button):
|
|
if box_button.text() != '&Yes':
|
|
return
|
|
|
|
database_filename = os.path.join(
|
|
self.main_window.database_path, 'Lector.db')
|
|
os.remove(database_filename)
|
|
QtWidgets.qApp.exit()
|
|
|
|
# Generate a message box to confirm deletion
|
|
confirm_deletion = QtWidgets.QMessageBox()
|
|
deletion_prompt = self._translate(
|
|
'SettingsUI', f'Delete database and exit?')
|
|
confirm_deletion.setText(deletion_prompt)
|
|
confirm_deletion.setIcon(QtWidgets.QMessageBox.Critical)
|
|
confirm_deletion.setWindowTitle(self._translate('SettingsUI', 'Confirm'))
|
|
confirm_deletion.setStandardButtons(
|
|
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
|
|
confirm_deletion.buttonClicked.connect(ifcontinue)
|
|
confirm_deletion.show()
|
|
confirm_deletion.exec_()
|
|
|
|
def clear_log(self):
|
|
self.logBox.clear()
|
|
open(logger_filename, 'w').close()
|