def do_user_config(self, parent=None):
'''
This method shows a configuration dialog for this plugin. It returns
True if the user clicks OK, False otherwise. The changes are
automatically applied.
'''
from qt.core import (QDialog, QDialogButtonBox, QVBoxLayout, QLabel,
Qt, QLineEdit, QCheckBox)
config_dialog = QDialog(parent)
button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel)
v = QVBoxLayout(config_dialog)
def size_dialog():
config_dialog.resize(config_dialog.sizeHint())
button_box.accepted.connect(config_dialog.accept)
button_box.rejected.connect(config_dialog.reject)
config_dialog.setWindowTitle(_('Customize') + ' ' + self.name)
from calibre.customize.ui import (plugin_customization,
customize_plugin)
help_text = self.customization_help(gui=True)
help_text = QLabel(help_text, config_dialog)
help_text.setWordWrap(True)
help_text.setTextInteractionFlags(
Qt.TextInteractionFlag.LinksAccessibleByMouse
| Qt.TextInteractionFlag.LinksAccessibleByKeyboard)
help_text.setOpenExternalLinks(True)
v.addWidget(help_text)
bf = QCheckBox(_('Add linked files in breadth first order'))
bf.setToolTip(
_('Normally, when following links in HTML files'
' calibre does it depth first, i.e. if file A links to B and '
' C, but B links to D, the files are added in the order A, B, D, C. '
' With this option, they will instead be added as A, B, C, D'))
sc = plugin_customization(self)
if not sc:
sc = ''
sc = sc.strip()
enc = sc.partition('|')[0]
bfs = sc.partition('|')[-1]
bf.setChecked(bfs == 'bf')
sc = QLineEdit(enc, config_dialog)
v.addWidget(sc)
v.addWidget(bf)
v.addWidget(button_box)
size_dialog()
config_dialog.exec()
if config_dialog.result() == QDialog.DialogCode.Accepted:
sc = str(sc.text()).strip()
if bf.isChecked():
sc += '|bf'
customize_plugin(self, sc)
return config_dialog.result()
class ChooseName(Dialog): # {{{
''' Chooses the filename for a newly imported file, with error checking '''
def __init__(self, candidate, parent=None):
self.candidate = candidate
self.filename = None
Dialog.__init__(self,
_('Choose file name'),
'choose-file-name',
parent=parent)
def setup_ui(self):
self.l = l = QFormLayout(self)
self.setLayout(l)
self.err_label = QLabel('')
self.name_edit = QLineEdit(self)
self.name_edit.textChanged.connect(self.verify)
self.name_edit.setText(self.candidate)
pos = self.candidate.rfind('.')
if pos > -1:
self.name_edit.setSelection(0, pos)
l.addRow(_('File &name:'), self.name_edit)
l.addRow(self.err_label)
l.addRow(self.bb)
def show_error(self, msg):
self.err_label.setText('<p style="color:red">' + msg)
return False
def verify(self):
return name_is_ok(str(self.name_edit.text()), self.show_error)
def accept(self):
if not self.verify():
return error_dialog(
self,
_('No name specified'),
_('You must specify a file name for the new file, with an extension.'
),
show=True)
n = str(self.name_edit.text()).replace('\\', '/')
name, ext = n.rpartition('.')[0::2]
self.filename = name + '.' + ext.lower()
super().accept()
class MovedDialog(QDialog): # {{{
def __init__(self, stats, location, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(_('No library found'))
self._l = l = QGridLayout(self)
self.setLayout(l)
self.stats, self.location = stats, location
loc = self.oldloc = location.replace('/', os.sep)
self.header = QLabel(_('No existing calibre library was found at %s. '
'If the library was moved, select its new location below. '
'Otherwise calibre will forget this library.')%loc)
self.header.setWordWrap(True)
ncols = 2
l.addWidget(self.header, 0, 0, 1, ncols)
self.cl = QLabel('<b>'+_('New location of this library:'))
l.addWidget(self.cl, l.rowCount(), 0, 1, ncols)
self.loc = QLineEdit(loc, self)
l.addWidget(self.loc, l.rowCount(), 0, 1, 1)
self.cd = QToolButton(self)
self.cd.setIcon(QIcon(I('document_open.png')))
self.cd.clicked.connect(self.choose_dir)
l.addWidget(self.cd, l.rowCount() - 1, 1, 1, 1)
self.bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Abort)
b = self.bb.addButton(_('Library moved'), QDialogButtonBox.ButtonRole.AcceptRole)
b.setIcon(QIcon(I('ok.png')))
b = self.bb.addButton(_('Forget library'), QDialogButtonBox.ButtonRole.RejectRole)
b.setIcon(QIcon(I('edit-clear.png')))
b.clicked.connect(self.forget_library)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
l.addWidget(self.bb, 3, 0, 1, ncols)
self.resize(self.sizeHint() + QSize(120, 0))
def choose_dir(self):
d = choose_dir(self, 'library moved choose new loc',
_('New library location'), default_dir=self.oldloc)
if d is not None:
self.loc.setText(d)
def forget_library(self):
self.stats.remove(self.location)
def accept(self):
newloc = unicode_type(self.loc.text())
if not db_class().exists_at(newloc):
error_dialog(self, _('No library found'),
_('No existing calibre library found at %s')%newloc,
show=True)
return
self.stats.rename(self.location, newloc)
self.newloc = newloc
QDialog.accept(self)
class DaysOfMonth(Base):
HELP = _('''\
Download this periodical every month, on the specified days.
The download will happen as soon after the specified time as
possible on the specified days of each month. For example,
if you choose the 1st and the 15th after 9:00 AM, the
periodical will be downloaded on the 1st and 15th of every
month, as soon after 9:00 AM as possible.
''')
def __init__(self, parent=None):
Base.__init__(self, parent)
self.l1 = QLabel(_('&Days of the month:'))
self.days = QLineEdit(self)
self.days.setToolTip(
_('Comma separated list of days of the month.'
' For example: 1, 15'))
self.l1.setBuddy(self.days)
self.l2 = QLabel(_('Download &after:'))
self.time = QTimeEdit(self)
self.time.setDisplayFormat('hh:mm AP')
self.l2.setBuddy(self.time)
self.l.addWidget(self.l1, 0, 0, 1, 1)
self.l.addWidget(self.days, 0, 1, 1, 1)
self.l.addWidget(self.l2, 1, 0, 1, 1)
self.l.addWidget(self.time, 1, 1, 1, 1)
def initialize(self, typ=None, val=None):
if val is None:
val = ((1, ), 6, 0)
days_of_month, hour, minute = val
self.days.setText(', '.join(map(str, map(int, days_of_month))))
self.time.setTime(QTime(hour, minute))
@property
def schedule(self):
parts = [
x.strip() for x in unicode_type(self.days.text()).split(',')
if x.strip()
]
try:
days_of_month = tuple(map(int, parts))
except:
days_of_month = (1, )
if not days_of_month:
days_of_month = (1, )
t = self.time.time()
hour, minute = t.hour(), t.minute()
return 'days_of_month', (days_of_month, int(hour), int(minute))
class AdvancedGroupBox(DeviceOptionsGroupBox):
def __init__(self, parent, device):
super(AdvancedGroupBox, self).__init__(parent, device,
_("Advanced options"))
# self.setTitle(_("Advanced Options"))
self.options_layout = QGridLayout()
self.options_layout.setObjectName("options_layout")
self.setLayout(self.options_layout)
self.support_newer_firmware_checkbox = create_checkbox(
_("Attempt to support newer firmware"),
_('Kobo routinely updates the firmware and the '
'database version. With this option calibre will attempt '
'to perform full read-write functionality - Here be Dragons!! '
'Enable only if you are comfortable with restoring your kobo '
'to factory defaults and testing software. '
'This driver supports firmware V2.x.x and DBVersion up to ') +
unicode_type(device.supported_dbversion),
device.get_pref('support_newer_firmware'))
self.debugging_title_checkbox = create_checkbox(
_("Title to test when debugging"),
_('Part of title of a book that can be used when doing some tests for debugging. '
'The test is to see if the string is contained in the title of a book. '
'The better the match, the less extraneous output.'),
device.get_pref('debugging_title'))
self.debugging_title_label = QLabel(_('Title to test when debugging:'))
self.debugging_title_edit = QLineEdit(self)
self.debugging_title_edit.setToolTip(
_('Part of title of a book that can be used when doing some tests for debugging. '
'The test is to see if the string is contained in the title of a book. '
'The better the match, the less extraneous output.'))
self.debugging_title_edit.setText(device.get_pref('debugging_title'))
self.debugging_title_label.setBuddy(self.debugging_title_edit)
self.options_layout.addWidget(self.support_newer_firmware_checkbox, 0,
0, 1, 2)
self.options_layout.addWidget(self.debugging_title_label, 1, 0, 1, 1)
self.options_layout.addWidget(self.debugging_title_edit, 1, 1, 1, 1)
@property
def support_newer_firmware(self):
return self.support_newer_firmware_checkbox.isChecked()
@property
def debugging_title(self):
return self.debugging_title_edit.text().strip()
class ConfigWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.l = QHBoxLayout()
self.setLayout(self.l)
self.label = QLabel('Hello world &message:')
self.l.addWidget(self.label)
self.msg = QLineEdit(self)
self.msg.setText(prefs['hello_world_msg'])
self.l.addWidget(self.msg)
self.label.setBuddy(self.msg)
def save_settings(self):
prefs['hello_world_msg'] = self.msg.text()
class CreateVirtualLibrary(QDialog): # {{{
def __init__(self, gui, existing_names, editing=None):
QDialog.__init__(self, gui)
self.gui = gui
self.existing_names = existing_names
if editing:
self.setWindowTitle(_('Edit Virtual library'))
else:
self.setWindowTitle(_('Create Virtual library'))
self.setWindowIcon(QIcon(I('lt.png')))
gl = QGridLayout()
self.setLayout(gl)
self.la1 = la1 = QLabel(_('Virtual library &name:'))
gl.addWidget(la1, 0, 0)
self.vl_name = QComboBox()
self.vl_name.setEditable(True)
self.vl_name.lineEdit().setMaxLength(MAX_VIRTUAL_LIBRARY_NAME_LENGTH)
la1.setBuddy(self.vl_name)
gl.addWidget(self.vl_name, 0, 1)
self.editing = editing
self.saved_searches_label = sl = QTextBrowser(self)
sl.viewport().setAutoFillBackground(False)
gl.addWidget(sl, 2, 0, 1, 2)
self.la2 = la2 = QLabel(_('&Search expression:'))
gl.addWidget(la2, 1, 0)
self.vl_text = QLineEdit()
self.vl_text.textChanged.connect(self.search_text_changed)
la2.setBuddy(self.vl_text)
gl.addWidget(self.vl_text, 1, 1)
# Trigger the textChanged signal to initialize the saved searches box
self.vl_text.setText(' ')
self.vl_text.setText(_build_full_search_string(self.gui))
self.sl = sl = QLabel('<p>'+_('Create a Virtual library based on: ')+
('<a href="author.{0}">{0}</a>, '
'<a href="tag.{1}">{1}</a>, '
'<a href="publisher.{2}">{2}</a>, '
'<a href="series.{3}">{3}</a>, '
'<a href="search.{4}">{4}</a>.').format(_('Authors'), _('Tags'),
_('Publishers'), ngettext('Series', 'Series', 2), _('Saved searches')))
sl.setWordWrap(True)
sl.setTextInteractionFlags(Qt.TextInteractionFlag.LinksAccessibleByMouse)
sl.linkActivated.connect(self.link_activated)
gl.addWidget(sl, 3, 0, 1, 2)
gl.setRowStretch(3,10)
self.hl = hl = QLabel(_('''
<h2>Virtual libraries</h2>
<p>With <i>Virtual libraries</i>, you can restrict calibre to only show
you books that match a search. When a Virtual library is in effect, calibre
behaves as though the library contains only the matched books. The Tag browser
display only the tags/authors/series/etc. that belong to the matched books and any searches
you do will only search within the books in the Virtual library. This
is a good way to partition your large library into smaller and easier to work with subsets.</p>
<p>For example you can use a Virtual library to only show you books with the tag <i>Unread</i>
or only books by <i>My favorite author</i> or only books in a particular series.</p>
<p>More information and examples are available in the
<a href="%s">User Manual</a>.</p>
''') % localize_user_manual_link('https://manual.calibre-ebook.com/virtual_libraries.html'))
hl.setWordWrap(True)
hl.setOpenExternalLinks(True)
hl.setFrameStyle(QFrame.Shape.StyledPanel)
gl.addWidget(hl, 0, 3, 4, 1)
bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
gl.addWidget(bb, 4, 0, 1, 0)
if editing:
db = self.gui.current_db
virt_libs = db.new_api.pref('virtual_libraries', {})
for dex,vl in enumerate(sorted(virt_libs.keys(), key=sort_key)):
self.vl_name.addItem(vl, virt_libs.get(vl, ''))
if vl == editing:
self.vl_name.setCurrentIndex(dex)
self.original_index = dex
self.original_search = virt_libs.get(editing, '')
self.vl_text.setText(self.original_search)
self.new_name = editing
self.vl_name.currentIndexChanged[int].connect(self.name_index_changed)
self.vl_name.lineEdit().textEdited.connect(self.name_text_edited)
self.resize(self.sizeHint()+QSize(150, 25))
def search_text_changed(self, txt):
db = self.gui.current_db
searches = [_('Saved searches recognized in the expression:')]
txt = str(txt)
while txt:
p = txt.partition('search:')
if p[1]: # found 'search:'
possible_search = p[2]
if possible_search: # something follows the 'search:'
if possible_search[0] == '"': # strip any quotes
possible_search = possible_search[1:].partition('"')
else: # find end of the search name. Is EOL, space, rparen
sp = possible_search.find(' ')
pp = possible_search.find(')')
if pp < 0 or (sp > 0 and sp <= pp):
# space in string before rparen, or neither found
possible_search = possible_search.partition(' ')
else:
# rparen in string before space
possible_search = possible_search.partition(')')
txt = possible_search[2] # grab remainder of the string
search_name = possible_search[0]
if search_name.startswith('='):
search_name = search_name[1:]
if search_name in db.saved_search_names():
searches.append(search_name + '=' +
db.saved_search_lookup(search_name))
else:
txt = ''
else:
txt = ''
self.saved_searches_label.setPlainText('\n'.join(searches))
def name_text_edited(self, new_name):
self.new_name = str(new_name)
def name_index_changed(self, dex):
if self.editing and (self.vl_text.text() != self.original_search or
self.new_name != self.editing):
if not question_dialog(self.gui, _('Search text changed'),
_('The Virtual library name or the search text has changed. '
'Do you want to discard these changes?'),
default_yes=False):
self.vl_name.blockSignals(True)
self.vl_name.setCurrentIndex(self.original_index)
self.vl_name.lineEdit().setText(self.new_name)
self.vl_name.blockSignals(False)
return
self.new_name = self.editing = self.vl_name.currentText()
self.original_index = dex
self.original_search = str(self.vl_name.itemData(dex) or '')
self.vl_text.setText(self.original_search)
def link_activated(self, url):
db = self.gui.current_db
f, txt = str(url).partition('.')[0::2]
if f == 'search':
names = db.saved_search_names()
else:
names = getattr(db, 'all_%s_names'%f)()
d = SelectNames(names, txt, parent=self)
if d.exec() == QDialog.DialogCode.Accepted:
prefix = f+'s' if f in {'tag', 'author'} else f
if f == 'search':
search = ['(%s)'%(db.saved_search_lookup(x)) for x in d.names]
else:
search = ['%s:"=%s"'%(prefix, x.replace('"', '\\"')) for x in d.names]
if search:
if not self.editing:
self.vl_name.lineEdit().setText(next(d.names))
self.vl_name.lineEdit().setCursorPosition(0)
self.vl_text.setText(d.match_type.join(search))
self.vl_text.setCursorPosition(0)
def accept(self):
n = str(self.vl_name.currentText()).strip()
if not n:
error_dialog(self.gui, _('No name'),
_('You must provide a name for the new Virtual library'),
show=True)
return
if n.startswith('*'):
error_dialog(self.gui, _('Invalid name'),
_('A Virtual library name cannot begin with "*"'),
show=True)
return
if n in self.existing_names and n != self.editing:
if not question_dialog(self.gui, _('Name already in use'),
_('That name is already in use. Do you want to replace it '
'with the new search?'),
default_yes=False):
return
v = str(self.vl_text.text()).strip()
if not v:
error_dialog(self.gui, _('No search string'),
_('You must provide a search to define the new Virtual library'),
show=True)
return
try:
db = self.gui.library_view.model().db
recs = db.data.search_getting_ids('', v, use_virtual_library=False, sort_results=False)
except ParseException as e:
error_dialog(self.gui, _('Invalid search'),
_('The search in the search box is not valid'),
det_msg=e.msg, show=True)
return
if not recs and not question_dialog(
self.gui, _('Search found no books'),
_('The search found no books, so the Virtual library '
'will be empty. Do you really want to use that search?'),
default_yes=False):
return
self.library_name = n
self.library_search = v
QDialog.accept(self)
def do_user_config(self, parent=None):
'''
This method shows a configuration dialog for this plugin. It returns
True if the user clicks OK, False otherwise. The changes are
automatically applied.
'''
from qt.core import QDialog, QDialogButtonBox, QVBoxLayout, \
QLabel, Qt, QLineEdit
from calibre.gui2 import gprefs
prefname = 'plugin config dialog:' + self.type + ':' + self.name
geom = gprefs.get(prefname, None)
config_dialog = QDialog(parent)
button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel)
v = QVBoxLayout(config_dialog)
def size_dialog():
if geom is None:
config_dialog.resize(config_dialog.sizeHint())
else:
from qt.core import QApplication
QApplication.instance().safe_restore_geometry(
config_dialog, geom)
button_box.accepted.connect(config_dialog.accept)
button_box.rejected.connect(config_dialog.reject)
config_dialog.setWindowTitle(_('Customize') + ' ' + self.name)
try:
config_widget = self.config_widget()
except NotImplementedError:
config_widget = None
if isinstance(config_widget, tuple):
from calibre.gui2 import warning_dialog
warning_dialog(parent,
_('Cannot configure'),
config_widget[0],
det_msg=config_widget[1],
show=True)
return False
if config_widget is not None:
v.addWidget(config_widget)
v.addWidget(button_box)
size_dialog()
config_dialog.exec()
if config_dialog.result() == QDialog.DialogCode.Accepted:
if hasattr(config_widget, 'validate'):
if config_widget.validate():
self.save_settings(config_widget)
else:
self.save_settings(config_widget)
else:
from calibre.customize.ui import plugin_customization, \
customize_plugin
help_text = self.customization_help(gui=True)
help_text = QLabel(help_text, config_dialog)
help_text.setWordWrap(True)
help_text.setTextInteractionFlags(
Qt.TextInteractionFlag.LinksAccessibleByMouse
| Qt.TextInteractionFlag.LinksAccessibleByKeyboard)
help_text.setOpenExternalLinks(True)
v.addWidget(help_text)
sc = plugin_customization(self)
if not sc:
sc = ''
sc = sc.strip()
sc = QLineEdit(sc, config_dialog)
v.addWidget(sc)
v.addWidget(button_box)
size_dialog()
config_dialog.exec()
if config_dialog.result() == QDialog.DialogCode.Accepted:
sc = str(sc.text()).strip()
customize_plugin(self, sc)
geom = bytearray(config_dialog.saveGeometry())
gprefs[prefname] = geom
return config_dialog.result()
class CollectionsGroupBox(DeviceOptionsGroupBox):
def __init__(self, parent, device):
super().__init__(parent, device)
self.setTitle(_("Collections"))
self.options_layout = QGridLayout()
self.options_layout.setObjectName("options_layout")
self.setLayout(self.options_layout)
self.setCheckable(True)
self.setChecked(device.get_pref('manage_collections'))
self.setToolTip(wrap_msg(_('Create new bookshelves on the Kobo if they do not exist. This is only for firmware V2.0.0 or later.')))
self.collections_columns_label = QLabel(_('Collections columns:'))
self.collections_columns_edit = QLineEdit(self)
self.collections_columns_edit.setToolTip(_('The Kobo from firmware V2.0.0 supports bookshelves.'
' These are created on the Kobo. '
'Specify a tags type column for automatic management.'))
self.collections_columns_edit.setText(device.get_pref('collections_columns'))
self.create_collections_checkbox = create_checkbox(
_("Create collections"),
_('Create new bookshelves on the Kobo if they do not exist. This is only for firmware V2.0.0 or later.'),
device.get_pref('create_collections')
)
self.delete_empty_collections_checkbox = create_checkbox(
_('Delete empty bookshelves'),
_('Delete any empty bookshelves from the Kobo when syncing is finished. This is only for firmware V2.0.0 or later.'),
device.get_pref('delete_empty_collections')
)
self.ignore_collections_names_label = QLabel(_('Ignore collections:'))
self.ignore_collections_names_edit = QLineEdit(self)
self.ignore_collections_names_edit.setToolTip(_('List the names of collections to be ignored by '
'the collection management. The collections listed '
'will not be changed. Names are separated by commas.'))
self.ignore_collections_names_edit.setText(device.get_pref('ignore_collections_names'))
self.options_layout.addWidget(self.collections_columns_label, 1, 0, 1, 1)
self.options_layout.addWidget(self.collections_columns_edit, 1, 1, 1, 1)
self.options_layout.addWidget(self.create_collections_checkbox, 2, 0, 1, 2)
self.options_layout.addWidget(self.delete_empty_collections_checkbox, 3, 0, 1, 2)
self.options_layout.addWidget(self.ignore_collections_names_label, 4, 0, 1, 1)
self.options_layout.addWidget(self.ignore_collections_names_edit, 4, 1, 1, 1)
@property
def manage_collections(self):
return self.isChecked()
@property
def collections_columns(self):
return self.collections_columns_edit.text().strip()
@property
def create_collections(self):
return self.create_collections_checkbox.isChecked()
@property
def delete_empty_collections(self):
return self.delete_empty_collections_checkbox.isChecked()
@property
def ignore_collections_names(self):
return self.ignore_collections_names_edit.text().strip()
class AddEmptyBookDialog(QDialog):
def __init__(self,
parent,
db,
author,
series=None,
title=None,
dup_title=None):
QDialog.__init__(self, parent)
self.db = db
self.setWindowTitle(_('How many empty books?'))
self._layout = QGridLayout(self)
self.setLayout(self._layout)
self.qty_label = QLabel(_('How many empty books should be added?'))
self._layout.addWidget(self.qty_label, 0, 0, 1, 2)
self.qty_spinbox = QSpinBox(self)
self.qty_spinbox.setRange(1, 10000)
self.qty_spinbox.setValue(1)
self._layout.addWidget(self.qty_spinbox, 1, 0, 1, 2)
self.author_label = QLabel(_('Set the author of the new books to:'))
self._layout.addWidget(self.author_label, 2, 0, 1, 2)
self.authors_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.authors_combo.setEditable(True)
self._layout.addWidget(self.authors_combo, 3, 0, 1, 1)
self.initialize_authors(db, author)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon(I('trash.png')))
self.clear_button.setToolTip(_('Reset author to Unknown'))
self.clear_button.clicked.connect(self.reset_author)
self._layout.addWidget(self.clear_button, 3, 1, 1, 1)
self.series_label = QLabel(_('Set the series of the new books to:'))
self._layout.addWidget(self.series_label, 4, 0, 1, 2)
self.series_combo = EditWithComplete(self)
self.series_combo.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.series_combo.setEditable(True)
self._layout.addWidget(self.series_combo, 5, 0, 1, 1)
self.initialize_series(db, series)
self.sclear_button = QToolButton(self)
self.sclear_button.setIcon(QIcon(I('trash.png')))
self.sclear_button.setToolTip(_('Reset series'))
self.sclear_button.clicked.connect(self.reset_series)
self._layout.addWidget(self.sclear_button, 5, 1, 1, 1)
self.title_label = QLabel(_('Set the title of the new books to:'))
self._layout.addWidget(self.title_label, 6, 0, 1, 2)
self.title_edit = QLineEdit(self)
self.title_edit.setText(title or '')
self._layout.addWidget(self.title_edit, 7, 0, 1, 1)
self.tclear_button = QToolButton(self)
self.tclear_button.setIcon(QIcon(I('trash.png')))
self.tclear_button.setToolTip(_('Reset title'))
self.tclear_button.clicked.connect(self.title_edit.clear)
self._layout.addWidget(self.tclear_button, 7, 1, 1, 1)
self.format_label = QLabel(_('Also create an empty e-book in format:'))
self._layout.addWidget(self.format_label, 8, 0, 1, 2)
c = self.format_value = QComboBox(self)
from calibre.ebooks.oeb.polish.create import valid_empty_formats
possible_formats = [''] + sorted(x.upper()
for x in valid_empty_formats)
c.addItems(possible_formats)
c.setToolTip(
_('Also create an empty book format file that you can subsequently edit'
))
if gprefs.get('create_empty_epub_file', False):
# Migration of the check box
gprefs.set('create_empty_format_file', 'epub')
del gprefs['create_empty_epub_file']
use_format = gprefs.get('create_empty_format_file', '').upper()
try:
c.setCurrentIndex(possible_formats.index(use_format))
except Exception:
pass
self._layout.addWidget(c, 9, 0, 1, 1)
self.copy_formats = cf = QCheckBox(
_('Also copy book &formats when duplicating a book'), self)
cf.setToolTip(
_('Also copy all e-book files into the newly created duplicate'
' books.'))
cf.setChecked(gprefs.get('create_empty_copy_dup_formats', False))
self._layout.addWidget(cf, 10, 0, 1, -1)
button_box = self.bb = QDialogButtonBox(
QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self._layout.addWidget(button_box, 11, 0, 1, -1)
if dup_title:
self.dup_button = b = button_box.addButton(
_('&Duplicate current book'),
QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.do_duplicate_book)
b.setIcon(QIcon(I('edit-copy.png')))
b.setToolTip(
_('Make the new empty book records exact duplicates\n'
'of the current book "%s", with all metadata identical') %
dup_title)
self.resize(self.sizeHint())
self.duplicate_current_book = False
def do_duplicate_book(self):
self.duplicate_current_book = True
self.accept()
def accept(self):
self.save_settings()
return QDialog.accept(self)
def save_settings(self):
gprefs['create_empty_format_file'] = self.format_value.currentText(
).lower()
gprefs['create_empty_copy_dup_formats'] = self.copy_formats.isChecked()
def reject(self):
self.save_settings()
return QDialog.reject(self)
def reset_author(self, *args):
self.authors_combo.setEditText(_('Unknown'))
def reset_series(self):
self.series_combo.setEditText('')
def initialize_authors(self, db, author):
au = author
if not au:
au = _('Unknown')
self.authors_combo.show_initial_value(au.replace('|', ','))
self.authors_combo.set_separator('&')
self.authors_combo.set_space_before_sep(True)
self.authors_combo.set_add_separator(
tweaks['authors_completer_append_separator'])
self.authors_combo.update_items_cache(db.all_author_names())
def initialize_series(self, db, series):
self.series_combo.show_initial_value(series or '')
self.series_combo.update_items_cache(db.all_series_names())
self.series_combo.set_separator(None)
@property
def qty_to_add(self):
return self.qty_spinbox.value()
@property
def selected_authors(self):
return string_to_authors(unicode_type(self.authors_combo.text()))
@property
def selected_series(self):
return unicode_type(self.series_combo.text())
@property
def selected_title(self):
return self.title_edit.text().strip()
class ItemEdit(QWidget):
def __init__(self, parent, prefs=None):
QWidget.__init__(self, parent)
self.prefs = prefs or gprefs
self.pending_search = None
self.current_frag = None
self.setLayout(QVBoxLayout())
self.la = la = QLabel(
'<b>' + _('Select a destination for the Table of Contents entry'))
self.layout().addWidget(la)
self.splitter = sp = QSplitter(self)
self.layout().addWidget(sp)
self.layout().setStretch(1, 10)
sp.setOpaqueResize(False)
sp.setChildrenCollapsible(False)
self.dest_list = dl = QListWidget(self)
dl.setMinimumWidth(250)
dl.currentItemChanged.connect(self.current_changed)
sp.addWidget(dl)
w = self.w = QWidget(self)
l = w.l = QGridLayout()
w.setLayout(l)
self.view = WebView(self, self.prefs)
self.view.elem_clicked.connect(self.elem_clicked)
self.view.frag_shown.connect(self.update_dest_label,
type=Qt.ConnectionType.QueuedConnection)
self.view.loadFinished.connect(self.load_finished,
type=Qt.ConnectionType.QueuedConnection)
l.addWidget(self.view, 0, 0, 1, 3)
sp.addWidget(w)
self.search_text = s = QLineEdit(self)
s.setPlaceholderText(_('Search for text...'))
s.returnPressed.connect(self.find_next)
l.addWidget(s, 1, 0)
self.ns_button = b = QPushButton(QIcon(I('arrow-down.png')),
_('Find &next'), self)
b.clicked.connect(self.find_next)
l.addWidget(b, 1, 1)
self.ps_button = b = QPushButton(QIcon(I('arrow-up.png')),
_('Find &previous'), self)
l.addWidget(b, 1, 2)
b.clicked.connect(self.find_previous)
self.f = f = QFrame()
f.setFrameShape(QFrame.Shape.StyledPanel)
f.setMinimumWidth(250)
l = f.l = QVBoxLayout()
f.setLayout(l)
sp.addWidget(f)
f.la = la = QLabel('<p>' + _(
'Here you can choose a destination for the Table of Contents\' entry'
' to point to. First choose a file from the book in the left-most panel. The'
' file will open in the central panel.<p>'
'Then choose a location inside the file. To do so, simply click on'
' the place in the central panel that you want to use as the'
' destination. As you move the mouse around the central panel, a'
' thick green line appears, indicating the precise location'
' that will be selected when you click.'))
la.setStyleSheet('QLabel { margin-bottom: 20px }')
la.setWordWrap(True)
l.addWidget(la)
f.la2 = la = QLabel('<b>' + _('Na&me of the ToC entry:'))
l.addWidget(la)
self.name = QLineEdit(self)
self.name.setPlaceholderText(_('(Untitled)'))
la.setBuddy(self.name)
l.addWidget(self.name)
self.base_msg = '<b>' + _('Currently selected destination:') + '</b>'
self.dest_label = la = QLabel(self.base_msg)
la.setWordWrap(True)
la.setStyleSheet('QLabel { margin-top: 20px }')
l.addWidget(la)
l.addStretch()
state = self.prefs.get('toc_edit_splitter_state', None)
if state is not None:
sp.restoreState(state)
def load_finished(self, ok):
if self.pending_search:
self.pending_search()
self.pending_search = None
def keyPressEvent(self, ev):
if ev.key() in (Qt.Key.Key_Return,
Qt.Key.Key_Enter) and self.search_text.hasFocus():
# Prevent pressing enter in the search box from triggering the dialog's accept() method
ev.accept()
return
return super().keyPressEvent(ev)
def find(self, forwards=True):
text = str(self.search_text.text()).strip()
flags = QWebEnginePage.FindFlags(
0) if forwards else QWebEnginePage.FindFlag.FindBackward
self.find_data = text, flags, forwards
self.view.findText(text, flags, self.find_callback)
def find_callback(self, found):
d = self.dest_list
text, flags, forwards = self.find_data
if not found and text:
if d.count() == 1:
return error_dialog(self,
_('No match found'),
_('No match found for: %s') % text,
show=True)
delta = 1 if forwards else -1
current = str(d.currentItem().data(Qt.ItemDataRole.DisplayRole)
or '')
next_index = (d.currentRow() + delta) % d.count()
next = str(
d.item(next_index).data(Qt.ItemDataRole.DisplayRole) or '')
msg = '<p>' + _(
'No matches for %(text)s found in the current file [%(current)s].'
' Do you want to search in the %(which)s file [%(next)s]?')
msg = msg % dict(text=text,
current=current,
next=next,
which=_('next') if forwards else _('previous'))
if question_dialog(self, _('No match found'), msg):
self.pending_search = self.find_next if forwards else self.find_previous
d.setCurrentRow(next_index)
def find_next(self):
return self.find()
def find_previous(self):
return self.find(forwards=False)
def load(self, container):
self.container = container
spine_names = [
container.abspath_to_name(p) for p in container.spine_items
]
spine_names = [n for n in spine_names if container.has_name(n)]
self.dest_list.addItems(spine_names)
def current_changed(self, item):
name = self.current_name = str(
item.data(Qt.ItemDataRole.DisplayRole) or '')
path = self.container.name_to_abspath(name)
# Ensure encoding map is populated
root = self.container.parsed(name)
nasty = root.xpath('//*[local-name()="head"]/*[local-name()="p"]')
if nasty:
body = root.xpath('//*[local-name()="body"]')
if not body:
return error_dialog(
self,
_('Bad markup'),
_('This book has severely broken markup, its ToC cannot be edited.'
),
show=True)
for x in reversed(nasty):
body[0].insert(0, x)
self.container.commit_item(name, keep_parsed=True)
self.view.load_path(path, self.current_frag)
self.current_frag = None
self.dest_label.setText(self.base_msg + '<br>' + _('File:') + ' ' +
name + '<br>' + _('Top of the file'))
def __call__(self, item, where):
self.current_item, self.current_where = item, where
self.current_name = None
self.current_frag = None
self.name.setText('')
dest_index, frag = 0, None
if item is not None:
if where is None:
self.name.setText(
item.data(0, Qt.ItemDataRole.DisplayRole) or '')
self.name.setCursorPosition(0)
toc = item.data(0, Qt.ItemDataRole.UserRole)
if toc.dest:
for i in range(self.dest_list.count()):
litem = self.dest_list.item(i)
if str(litem.data(Qt.ItemDataRole.DisplayRole)
or '') == toc.dest:
dest_index = i
frag = toc.frag
break
self.dest_list.blockSignals(True)
self.dest_list.setCurrentRow(dest_index)
self.dest_list.blockSignals(False)
item = self.dest_list.item(dest_index)
if frag:
self.current_frag = frag
self.current_changed(item)
def get_loctext(self, frac):
frac = int(round(frac * 100))
if frac == 0:
loctext = _('Top of the file')
else:
loctext = _('Approximately %d%% from the top') % frac
return loctext
def elem_clicked(self, tag, frac, elem_id, loc, totals):
self.current_frag = elem_id or (loc, totals)
base = _('Location: A <%s> tag inside the file') % tag
loctext = base + ' [%s]' % self.get_loctext(frac)
self.dest_label.setText(self.base_msg + '<br>' + _('File:') + ' ' +
self.current_name + '<br>' + loctext)
def update_dest_label(self, val):
self.dest_label.setText(self.base_msg + '<br>' + _('File:') + ' ' +
self.current_name + '<br>' +
self.get_loctext(val))
@property
def result(self):
return (self.current_item, self.current_where, self.current_name,
self.current_frag, self.name.text().strip() or _('(Untitled)'))
class ThemeCreateDialog(Dialog):
def __init__(self, parent, report):
self.report = report
Dialog.__init__(self, _('Create an icon theme'), 'create-icon-theme',
parent)
def setup_ui(self):
self.splitter = QSplitter(self)
self.l = l = QVBoxLayout(self)
l.addWidget(self.splitter)
l.addWidget(self.bb)
self.w = w = QGroupBox(_('Theme Metadata'), self)
self.splitter.addWidget(w)
l = w.l = QFormLayout(w)
l.setFieldGrowthPolicy(
QFormLayout.FieldGrowthPolicy.ExpandingFieldsGrow)
self.missing_icons_group = mg = QGroupBox(self)
self.mising_icons = mi = QListWidget(mg)
mi.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
mg.l = QVBoxLayout(mg)
mg.l.addWidget(mi)
self.splitter.addWidget(mg)
self.title = QLineEdit(self)
l.addRow(_('&Title:'), self.title)
self.author = QLineEdit(self)
l.addRow(_('&Author:'), self.author)
self.version = v = QSpinBox(self)
v.setMinimum(1), v.setMaximum(1000000)
l.addRow(_('&Version:'), v)
self.license = lc = QLineEdit(self)
l.addRow(_('&License:'), lc)
self.url = QLineEdit(self)
l.addRow(_('&URL:'), self.url)
lc.setText(
_('The license for the icons in this theme. Common choices are'
' Creative Commons or Public Domain.'))
self.description = QTextEdit(self)
l.addRow(self.description)
self.refresh_button = rb = self.bb.addButton(
_('&Refresh'), QDialogButtonBox.ButtonRole.ActionRole)
rb.setIcon(QIcon(I('view-refresh.png')))
rb.clicked.connect(self.refresh)
self.apply_report()
def sizeHint(self):
return QSize(900, 670)
@property
def metadata(self):
self.report.theme.title = self.title.text().strip(
) # Needed for report.name to work
return {
'title': self.title.text().strip(),
'author': self.author.text().strip(),
'version': self.version.value(),
'description': self.description.toPlainText().strip(),
'number': len(self.report.name_map) - len(self.report.extra),
'date': utcnow().date().isoformat(),
'name': self.report.name,
'license': self.license.text().strip() or 'Unknown',
'url': self.url.text().strip() or None,
}
def save_metadata(self):
data = json.dumps(self.metadata, indent=2)
if not isinstance(data, bytes):
data = data.encode('utf-8')
with open(os.path.join(self.report.path, THEME_METADATA), 'wb') as f:
f.write(data)
def refresh(self):
self.save_metadata()
self.report = read_theme_from_folder(self.report.path)
self.apply_report()
def apply_report(self):
theme = self.report.theme
self.title.setText((theme.title or '').strip())
self.author.setText((theme.author or '').strip())
self.version.setValue(theme.version or 1)
self.description.setText((theme.description or '').strip())
self.license.setText((theme.license or 'Unknown').strip())
self.url.setText((theme.url or '').strip())
if self.report.missing:
title = _('%d icons missing in this theme') % len(
self.report.missing)
else:
title = _('No missing icons')
self.missing_icons_group.setTitle(title)
mi = self.mising_icons
mi.clear()
for name in sorted(self.report.missing):
QListWidgetItem(QIcon(I(name, allow_user_override=False)), name,
mi)
def accept(self):
mi = self.metadata
if not mi.get('title'):
return error_dialog(
self,
_('No title specified'),
_('You must specify a title for this icon theme'),
show=True)
if not mi.get('author'):
return error_dialog(
self,
_('No author specified'),
_('You must specify an author for this icon theme'),
show=True)
return Dialog.accept(self)
class ExtraCustomization(DeviceConfigTab): # {{{
def __init__(self, extra_customization_message,
extra_customization_choices, device_settings):
super(ExtraCustomization, self).__init__()
debug_print(
"ExtraCustomization.__init__ - extra_customization_message=",
extra_customization_message)
debug_print(
"ExtraCustomization.__init__ - extra_customization_choices=",
extra_customization_choices)
debug_print(
"ExtraCustomization.__init__ - device_settings.extra_customization=",
device_settings.extra_customization)
debug_print("ExtraCustomization.__init__ - device_settings=",
device_settings)
self.extra_customization_message = extra_customization_message
self.l = QVBoxLayout(self)
self.setLayout(self.l)
options_group = QGroupBox(_("Extra driver customization options"),
self)
self.l.addWidget(options_group)
self.extra_layout = QGridLayout()
self.extra_layout.setObjectName("extra_layout")
options_group.setLayout(self.extra_layout)
if extra_customization_message:
extra_customization_choices = extra_customization_choices or {}
def parse_msg(m):
msg, _, tt = m.partition(':::') if m else ('', '', '')
return msg.strip(), textwrap.fill(tt.strip(), 100)
if isinstance(extra_customization_message, list):
self.opt_extra_customization = []
if len(extra_customization_message) > 6:
row_func = lambda x, y: ((x // 2) * 2) + y
col_func = lambda x: x % 2
else:
row_func = lambda x, y: x * 2 + y
col_func = lambda x: 0
for i, m in enumerate(extra_customization_message):
label_text, tt = parse_msg(m)
if not label_text:
self.opt_extra_customization.append(None)
continue
if isinstance(device_settings.extra_customization[i],
bool):
self.opt_extra_customization.append(
QCheckBox(label_text))
self.opt_extra_customization[-1].setToolTip(tt)
self.opt_extra_customization[i].setChecked(
bool(device_settings.extra_customization[i]))
elif i in extra_customization_choices:
cb = QComboBox(self)
self.opt_extra_customization.append(cb)
l = QLabel(label_text)
l.setToolTip(tt), cb.setToolTip(tt), l.setBuddy(
cb), cb.setToolTip(tt)
for li in sorted(extra_customization_choices[i]):
self.opt_extra_customization[i].addItem(li)
cb.setCurrentIndex(
max(
0,
cb.findText(
device_settings.extra_customization[i])))
else:
self.opt_extra_customization.append(QLineEdit(self))
l = QLabel(label_text)
l.setToolTip(tt)
self.opt_extra_customization[i].setToolTip(tt)
l.setBuddy(self.opt_extra_customization[i])
l.setWordWrap(True)
self.opt_extra_customization[i].setText(
device_settings.extra_customization[i])
self.opt_extra_customization[i].setCursorPosition(0)
self.extra_layout.addWidget(l, row_func(i + 2, 0),
col_func(i))
self.extra_layout.addWidget(
self.opt_extra_customization[i], row_func(i + 2, 1),
col_func(i))
spacerItem1 = QSpacerItem(10, 10, QSizePolicy.Policy.Minimum,
QSizePolicy.Policy.Expanding)
self.extra_layout.addItem(spacerItem1, row_func(i + 2 + 2, 1),
0, 1, 2)
self.extra_layout.setRowStretch(row_func(i + 2 + 2, 1), 2)
else:
self.opt_extra_customization = QLineEdit()
label_text, tt = parse_msg(extra_customization_message)
l = QLabel(label_text)
l.setToolTip(tt)
l.setBuddy(self.opt_extra_customization)
l.setWordWrap(True)
if device_settings.extra_customization:
self.opt_extra_customization.setText(
device_settings.extra_customization)
self.opt_extra_customization.setCursorPosition(0)
self.opt_extra_customization.setCursorPosition(0)
self.extra_layout.addWidget(l, 0, 0)
self.extra_layout.addWidget(self.opt_extra_customization, 1, 0)
def extra_customization(self):
ec = []
if self.extra_customization_message:
if isinstance(self.extra_customization_message, list):
for i in range(0, len(self.extra_customization_message)):
if self.opt_extra_customization[i] is None:
ec.append(None)
continue
if hasattr(self.opt_extra_customization[i], 'isChecked'):
ec.append(self.opt_extra_customization[i].isChecked())
elif hasattr(self.opt_extra_customization[i],
'currentText'):
ec.append(
unicode_type(self.opt_extra_customization[i].
currentText()).strip())
else:
ec.append(
unicode_type(self.opt_extra_customization[i].text(
)).strip())
else:
ec = unicode_type(self.opt_extra_customization.text()).strip()
if not ec:
ec = None
return ec
@property
def has_extra_customizations(self):
debug_print(
"ExtraCustomization::has_extra_customizations - self.extra_customization_message",
self.extra_customization_message)
return self.extra_customization_message and len(
self.extra_customization_message) > 0
class FontFamilyDialog(QDialog):
def __init__(self, current_family, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(_('Choose font family'))
self.setWindowIcon(QIcon(I('font.png')))
from calibre.utils.fonts.scanner import font_scanner
self.font_scanner = font_scanner
self.m = QStringListModel(self)
self.build_font_list()
self.l = l = QGridLayout()
self.setLayout(l)
self.view = FontsView(self)
self.view.setModel(self.m)
self.view.setCurrentIndex(self.m.index(0))
if current_family:
for i, val in enumerate(self.families):
if icu_lower(val) == icu_lower(current_family):
self.view.setCurrentIndex(self.m.index(i))
break
self.view.doubleClicked.connect(
self.accept, type=Qt.ConnectionType.QueuedConnection)
self.view.changed.connect(self.current_changed,
type=Qt.ConnectionType.QueuedConnection)
self.faces = Typefaces(self)
self.bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.add_fonts_button = afb = self.bb.addButton(
_('Add &fonts'), QDialogButtonBox.ButtonRole.ActionRole)
afb.setIcon(QIcon(I('plus.png')))
afb.clicked.connect(self.add_fonts)
self.ml = QLabel(_('Choose a font family from the list below:'))
self.search = QLineEdit(self)
self.search.setPlaceholderText(_('Search'))
self.search.returnPressed.connect(self.find)
self.nb = QToolButton(self)
self.nb.setIcon(QIcon(I('arrow-down.png')))
self.nb.setToolTip(_('Find next'))
self.pb = QToolButton(self)
self.pb.setIcon(QIcon(I('arrow-up.png')))
self.pb.setToolTip(_('Find previous'))
self.nb.clicked.connect(self.find_next)
self.pb.clicked.connect(self.find_previous)
l.addWidget(self.ml, 0, 0, 1, 4)
l.addWidget(self.search, 1, 0, 1, 1)
l.addWidget(self.nb, 1, 1, 1, 1)
l.addWidget(self.pb, 1, 2, 1, 1)
l.addWidget(self.view, 2, 0, 1, 3)
l.addWidget(self.faces, 1, 3, 2, 1)
l.addWidget(self.bb, 3, 0, 1, 4)
l.setAlignment(self.faces, Qt.AlignmentFlag.AlignTop)
self.resize(800, 600)
def set_current(self, i):
self.view.setCurrentIndex(self.m.index(i))
def keyPressEvent(self, e):
if e.key() == Qt.Key.Key_Return:
return
return QDialog.keyPressEvent(self, e)
def find(self, backwards=False):
i = self.view.currentIndex().row()
if i < 0:
i = 0
q = icu_lower(unicode_type(self.search.text())).strip()
if not q:
return
r = (range(i -
1, -1, -1) if backwards else range(i +
1, len(self.families)))
for j in r:
f = self.families[j]
if q in icu_lower(f):
self.set_current(j)
return
def find_next(self):
self.find()
def find_previous(self):
self.find(backwards=True)
def build_font_list(self):
try:
self.families = list(self.font_scanner.find_font_families())
except:
self.families = []
print('WARNING: Could not load fonts')
import traceback
traceback.print_exc()
self.families.insert(0, _('None'))
self.m.setStringList(self.families)
def add_fonts(self):
families = add_fonts(self)
if not families:
return
self.font_scanner.do_scan()
self.m.beginResetModel()
self.build_font_list()
self.m.endResetModel()
self.view.setCurrentIndex(self.m.index(0))
if families:
for i, val in enumerate(self.families):
if icu_lower(val) == icu_lower(families[0]):
self.view.setCurrentIndex(self.m.index(i))
break
info_dialog(self,
_('Added fonts'),
_('Added font families: %s') % (', '.join(families)),
show=True)
@property
def font_family(self):
idx = self.view.currentIndex().row()
if idx == 0:
return None
return self.families[idx]
def current_changed(self):
fam = self.font_family
self.faces.show_family(
fam,
self.font_scanner.fonts_for_family(fam) if fam else None)
class CheckLibraryDialog(QDialog):
is_deletable = 1
is_fixable = 2
def __init__(self, parent, db):
QDialog.__init__(self, parent)
self.db = db
self.setWindowTitle(_('Check library -- Problems found'))
self.setWindowIcon(QIcon(I('debug.png')))
self._tl = QHBoxLayout()
self.setLayout(self._tl)
self.splitter = QSplitter(self)
self.left = QWidget(self)
self.splitter.addWidget(self.left)
self.helpw = QTextEdit(self)
self.splitter.addWidget(self.helpw)
self._tl.addWidget(self.splitter)
self._layout = QVBoxLayout()
self.left.setLayout(self._layout)
self.helpw.setReadOnly(True)
self.helpw.setText(
_('''\
<h1>Help</h1>
<p>calibre stores the list of your books and their metadata in a
database. The actual book files and covers are stored as normal
files in the calibre library folder. The database contains a list of the files
and covers belonging to each book entry. This tool checks that the
actual files in the library folder on your computer match the
information in the database.</p>
<p>The result of each type of check is shown to the left. The various
checks are:
</p>
<ul>
<li><b>Invalid titles</b>: These are files and folders appearing
in the library where books titles should, but that do not have the
correct form to be a book title.</li>
<li><b>Extra titles</b>: These are extra files in your calibre
library that appear to be correctly-formed titles, but have no corresponding
entries in the database.</li>
<li><b>Invalid authors</b>: These are files appearing
in the library where only author folders should be.</li>
<li><b>Extra authors</b>: These are folders in the
calibre library that appear to be authors but that do not have entries
in the database.</li>
<li><b>Missing book formats</b>: These are book formats that are in
the database but have no corresponding format file in the book's folder.
<li><b>Extra book formats</b>: These are book format files found in
the book's folder but not in the database.
<li><b>Unknown files in books</b>: These are extra files in the
folder of each book that do not correspond to a known format or cover
file.</li>
<li><b>Missing cover files</b>: These represent books that are marked
in the database as having covers but the actual cover files are
missing.</li>
<li><b>Cover files not in database</b>: These are books that have
cover files but are marked as not having covers in the database.</li>
<li><b>Folder raising exception</b>: These represent folders in the
calibre library that could not be processed/understood by this
tool.</li>
</ul>
<p>There are two kinds of automatic fixes possible: <i>Delete
marked</i> and <i>Fix marked</i>.</p>
<p><i>Delete marked</i> is used to remove extra files/folders/covers that
have no entries in the database. Check the box next to the item you want
to delete. Use with caution.</p>
<p><i>Fix marked</i> is applicable only to covers and missing formats
(the three lines marked 'fixable'). In the case of missing cover files,
checking the fixable box and pushing this button will tell calibre that
there is no cover for all of the books listed. Use this option if you
are not going to restore the covers from a backup. In the case of extra
cover files, checking the fixable box and pushing this button will tell
calibre that the cover files it found are correct for all the books
listed. Use this when you are not going to delete the file(s). In the
case of missing formats, checking the fixable box and pushing this
button will tell calibre that the formats are really gone. Use this if
you are not going to restore the formats from a backup.</p>
'''))
self.log = QTreeWidget(self)
self.log.itemChanged.connect(self.item_changed)
self.log.itemExpanded.connect(self.item_expanded_or_collapsed)
self.log.itemCollapsed.connect(self.item_expanded_or_collapsed)
self._layout.addWidget(self.log)
self.check_button = QPushButton(_('&Run the check again'))
self.check_button.setDefault(False)
self.check_button.clicked.connect(self.run_the_check)
self.copy_button = QPushButton(_('Copy &to clipboard'))
self.copy_button.setDefault(False)
self.copy_button.clicked.connect(self.copy_to_clipboard)
self.ok_button = QPushButton(_('&Done'))
self.ok_button.setDefault(True)
self.ok_button.clicked.connect(self.accept)
self.mark_delete_button = QPushButton(_('Mark &all for delete'))
self.mark_delete_button.setToolTip(_('Mark all deletable subitems'))
self.mark_delete_button.setDefault(False)
self.mark_delete_button.clicked.connect(self.mark_for_delete)
self.delete_button = QPushButton(_('Delete &marked'))
self.delete_button.setToolTip(
_('Delete marked files (checked subitems)'))
self.delete_button.setDefault(False)
self.delete_button.clicked.connect(self.delete_marked)
self.mark_fix_button = QPushButton(_('Mar&k all for fix'))
self.mark_fix_button.setToolTip(_('Mark all fixable items'))
self.mark_fix_button.setDefault(False)
self.mark_fix_button.clicked.connect(self.mark_for_fix)
self.fix_button = QPushButton(_('&Fix marked'))
self.fix_button.setDefault(False)
self.fix_button.setEnabled(False)
self.fix_button.setToolTip(
_('Fix marked sections (checked fixable items)'))
self.fix_button.clicked.connect(self.fix_items)
self.bbox = QGridLayout()
self.bbox.addWidget(self.check_button, 0, 0)
self.bbox.addWidget(self.copy_button, 0, 1)
self.bbox.addWidget(self.ok_button, 0, 2)
self.bbox.addWidget(self.mark_delete_button, 1, 0)
self.bbox.addWidget(self.delete_button, 1, 1)
self.bbox.addWidget(self.mark_fix_button, 2, 0)
self.bbox.addWidget(self.fix_button, 2, 1)
h = QHBoxLayout()
ln = QLabel(_('Names to ignore:'))
h.addWidget(ln)
self.name_ignores = QLineEdit()
self.name_ignores.setText(
db.new_api.pref('check_library_ignore_names', ''))
self.name_ignores.setToolTip(
_('Enter comma-separated standard file name wildcards, such as synctoy*.dat'
))
ln.setBuddy(self.name_ignores)
h.addWidget(self.name_ignores)
le = QLabel(_('Extensions to ignore:'))
h.addWidget(le)
self.ext_ignores = QLineEdit()
self.ext_ignores.setText(
db.new_api.pref('check_library_ignore_extensions', ''))
self.ext_ignores.setToolTip(
_('Enter comma-separated extensions without a leading dot. Used only in book folders'
))
le.setBuddy(self.ext_ignores)
h.addWidget(self.ext_ignores)
self._layout.addLayout(h)
self._layout.addLayout(self.bbox)
self.resize(950, 500)
def do_exec(self):
self.run_the_check()
probs = 0
for c in self.problem_count:
probs += self.problem_count[c]
if probs == 0:
return False
self.exec_()
return True
def accept(self):
self.db.new_api.set_pref('check_library_ignore_extensions',
str(self.ext_ignores.text()))
self.db.new_api.set_pref('check_library_ignore_names',
str(self.name_ignores.text()))
QDialog.accept(self)
def box_to_list(self, txt):
return [f.strip() for f in txt.split(',') if f.strip()]
def run_the_check(self):
checker = CheckLibrary(self.db.library_path, self.db)
checker.scan_library(self.box_to_list(str(self.name_ignores.text())),
self.box_to_list(str(self.ext_ignores.text())))
plaintext = []
def builder(tree, checker, check):
attr, h, checkable, fixable = check
list_ = getattr(checker, attr, None)
if list_ is None:
self.problem_count[attr] = 0
return
else:
self.problem_count[attr] = len(list_)
tl = Item()
tl.setText(0, h)
if fixable and list:
tl.setData(1, Qt.ItemDataRole.UserRole, self.is_fixable)
tl.setText(1, _('(fixable)'))
tl.setFlags(Qt.ItemFlag.ItemIsEnabled
| Qt.ItemFlag.ItemIsUserCheckable)
tl.setCheckState(1, False)
else:
tl.setData(1, Qt.ItemDataRole.UserRole, self.is_deletable)
tl.setData(2, Qt.ItemDataRole.UserRole, self.is_deletable)
tl.setText(1, _('(deletable)'))
tl.setFlags(Qt.ItemFlag.ItemIsEnabled
| Qt.ItemFlag.ItemIsUserCheckable)
tl.setCheckState(1, False)
if attr == 'extra_covers':
tl.setData(2, Qt.ItemDataRole.UserRole, self.is_deletable)
tl.setText(2, _('(deletable)'))
tl.setFlags(Qt.ItemFlag.ItemIsEnabled
| Qt.ItemFlag.ItemIsUserCheckable)
tl.setCheckState(2, False)
self.top_level_items[attr] = tl
for problem in list_:
it = Item()
if checkable:
it.setFlags(Qt.ItemFlag.ItemIsEnabled
| Qt.ItemFlag.ItemIsUserCheckable)
it.setCheckState(2, False)
it.setData(2, Qt.ItemDataRole.UserRole, self.is_deletable)
else:
it.setFlags(Qt.ItemFlag.ItemIsEnabled)
it.setText(0, problem[0])
it.setData(0, Qt.ItemDataRole.UserRole, problem[2])
it.setText(2, problem[1])
tl.addChild(it)
self.all_items.append(it)
plaintext.append(','.join([h, problem[0], problem[1]]))
tree.addTopLevelItem(tl)
t = self.log
t.clear()
t.setColumnCount(3)
t.setHeaderLabels([_('Name'), '', _('Path from library')])
self.all_items = []
self.top_level_items = {}
self.problem_count = {}
for check in CHECKS:
builder(t, checker, check)
t.resizeColumnToContents(0)
t.resizeColumnToContents(1)
self.delete_button.setEnabled(False)
self.fix_button.setEnabled(False)
self.text_results = '\n'.join(plaintext)
def item_expanded_or_collapsed(self, item):
self.log.resizeColumnToContents(0)
self.log.resizeColumnToContents(1)
def item_changed(self, item, column):
def set_delete_boxes(node, col, to_what):
self.log.blockSignals(True)
if col:
node.setCheckState(col, to_what)
for i in range(0, node.childCount()):
node.child(i).setCheckState(2, to_what)
self.log.blockSignals(False)
def is_child_delete_checked(node):
checked = False
all_checked = True
for i in range(0, node.childCount()):
c = node.child(i).checkState(2)
checked = checked or c == Qt.CheckState.Checked
all_checked = all_checked and c == Qt.CheckState.Checked
return (checked, all_checked)
def any_child_delete_checked():
for parent in self.top_level_items.values():
(c, _) = is_child_delete_checked(parent)
if c:
return True
return False
def any_fix_checked():
for parent in self.top_level_items.values():
if (parent.data(1, Qt.ItemDataRole.UserRole) == self.is_fixable
and parent.checkState(1) == Qt.CheckState.Checked):
return True
return False
if item in self.top_level_items.values():
if item.childCount() > 0:
if item.data(1, Qt.ItemDataRole.UserRole
) == self.is_fixable and column == 1:
if item.data(
2, Qt.ItemDataRole.UserRole) == self.is_deletable:
set_delete_boxes(item, 2, False)
else:
set_delete_boxes(item, column, item.checkState(column))
if column == 2:
self.log.blockSignals(True)
item.setCheckState(1, False)
self.log.blockSignals(False)
else:
item.setCheckState(column, Qt.CheckState.Unchecked)
else:
for parent in self.top_level_items.values():
if parent.data(2,
Qt.ItemDataRole.UserRole) == self.is_deletable:
(child_chkd, all_chkd) = is_child_delete_checked(parent)
if all_chkd and child_chkd:
check_state = Qt.CheckState.Checked
elif child_chkd:
check_state = Qt.CheckState.PartiallyChecked
else:
check_state = Qt.CheckState.Unchecked
self.log.blockSignals(True)
if parent.data(
1, Qt.ItemDataRole.UserRole) == self.is_fixable:
parent.setCheckState(2, check_state)
else:
parent.setCheckState(1, check_state)
if child_chkd and parent.data(
1, Qt.ItemDataRole.UserRole) == self.is_fixable:
parent.setCheckState(1, Qt.CheckState.Unchecked)
self.log.blockSignals(False)
self.delete_button.setEnabled(any_child_delete_checked())
self.fix_button.setEnabled(any_fix_checked())
def mark_for_fix(self):
for it in self.top_level_items.values():
if (it.flags() & Qt.ItemFlag.ItemIsUserCheckable
and it.data(1, Qt.ItemDataRole.UserRole) == self.is_fixable
and it.childCount() > 0):
it.setCheckState(1, Qt.CheckState.Checked)
def mark_for_delete(self):
for it in self.all_items:
if (it.flags() & Qt.ItemFlag.ItemIsUserCheckable and it.data(
2, Qt.ItemDataRole.UserRole) == self.is_deletable):
it.setCheckState(2, Qt.CheckState.Checked)
def delete_marked(self):
if not confirm(
'<p>' + _('The marked files and folders will be '
'<b>permanently deleted</b>. Are you sure?') +
'</p>', 'check_library_editor_delete', self):
return
# Sort the paths in reverse length order so that we can be sure that
# if an item is in another item, the sub-item will be deleted first.
items = sorted(self.all_items,
key=lambda x: len(x.text(1)),
reverse=True)
for it in items:
if it.checkState(2) == Qt.CheckState.Checked:
try:
p = os.path.join(self.db.library_path, str(it.text(2)))
if os.path.isdir(p):
delete_tree(p)
else:
delete_file(p)
except:
prints('failed to delete',
os.path.join(self.db.library_path, str(it.text(2))))
self.run_the_check()
def fix_missing_formats(self):
tl = self.top_level_items['missing_formats']
child_count = tl.childCount()
for i in range(0, child_count):
item = tl.child(i)
id = int(item.data(0, Qt.ItemDataRole.UserRole))
all = self.db.formats(id, index_is_id=True, verify_formats=False)
all = {f.strip() for f in all.split(',')} if all else set()
valid = self.db.formats(id, index_is_id=True, verify_formats=True)
valid = {f.strip() for f in valid.split(',')} if valid else set()
for fmt in all - valid:
self.db.remove_format(id, fmt, index_is_id=True, db_only=True)
def fix_missing_covers(self):
tl = self.top_level_items['missing_covers']
child_count = tl.childCount()
for i in range(0, child_count):
item = tl.child(i)
id = int(item.data(0, Qt.ItemDataRole.UserRole))
self.db.set_has_cover(id, False)
def fix_extra_covers(self):
tl = self.top_level_items['extra_covers']
child_count = tl.childCount()
for i in range(0, child_count):
item = tl.child(i)
id = int(item.data(0, Qt.ItemDataRole.UserRole))
self.db.set_has_cover(id, True)
def fix_items(self):
for check in CHECKS:
attr = check[0]
fixable = check[3]
tl = self.top_level_items[attr]
if fixable and tl.checkState(1):
func = getattr(self, 'fix_' + attr, None)
if func is not None and callable(func):
func()
self.run_the_check()
def copy_to_clipboard(self):
QApplication.clipboard().setText(self.text_results)
class CollectionsGroupBox(DeviceOptionsGroupBox):
def __init__(self, parent, device):
super().__init__(parent, device)
self.setTitle(_("Collections"))
self.options_layout = QGridLayout()
self.options_layout.setObjectName("options_layout")
self.setLayout(self.options_layout)
self.setCheckable(True)
self.setChecked(device.get_pref('manage_collections'))
self.setToolTip(
wrap_msg(
_('Create new bookshelves on the Kobo if they do not exist. This is only for firmware V2.0.0 or later.'
)))
self.use_collections_columns_checkbox = create_checkbox(
_("Collections columns:"),
_('Use a column to generate collections.'),
device.get_pref('use_collections_columns'))
self.collections_columns_edit = QLineEdit(self)
self.collections_columns_edit.setToolTip(
_('The Kobo from firmware V2.0.0 supports bookshelves.'
' These are created on the Kobo. '
'Specify a tags type column for automatic management.'))
self.collections_columns_edit.setText(
device.get_pref('collections_columns'))
self.use_collections_template_checkbox = create_checkbox(
_("Collections template:"),
_('Use a template to generate collections.'),
device.get_pref('use_collections_template'))
self.collections_template_edit = TemplateConfig(
device.get_pref('collections_template'),
tooltip=
_("Enter a template to generate collections."
" The result of the template will be combined with the values from Collections column."
" The template should return a list of collection names separated by ':@:' (without quotes)."
))
self.create_collections_checkbox = create_checkbox(
_("Create collections"),
_('Create new bookshelves on the Kobo if they do not exist. This is only for firmware V2.0.0 or later.'
), device.get_pref('create_collections'))
self.delete_empty_collections_checkbox = create_checkbox(
_('Delete empty bookshelves'),
_('Delete any empty bookshelves from the Kobo when syncing is finished. This is only for firmware V2.0.0 or later.'
), device.get_pref('delete_empty_collections'))
self.ignore_collections_names_label = QLabel(_('Ignore collections:'))
self.ignore_collections_names_edit = QLineEdit(self)
self.ignore_collections_names_edit.setToolTip(
_('List the names of collections to be ignored by '
'the collection management. The collections listed '
'will not be changed. Names are separated by commas.'))
self.ignore_collections_names_edit.setText(
device.get_pref('ignore_collections_names'))
self.options_layout.addWidget(self.use_collections_columns_checkbox, 1,
0, 1, 1)
self.options_layout.addWidget(self.collections_columns_edit, 1, 1, 1,
1)
self.options_layout.addWidget(self.use_collections_template_checkbox,
2, 0, 1, 1)
self.options_layout.addWidget(self.collections_template_edit, 2, 1, 1,
1)
self.options_layout.addWidget(self.create_collections_checkbox, 3, 0,
1, 2)
self.options_layout.addWidget(self.delete_empty_collections_checkbox,
4, 0, 1, 2)
self.options_layout.addWidget(self.ignore_collections_names_label, 5,
0, 1, 1)
self.options_layout.addWidget(self.ignore_collections_names_edit, 5, 1,
1, 1)
self.use_collections_columns_checkbox.clicked.connect(
self.use_collections_columns_checkbox_clicked)
self.use_collections_template_checkbox.clicked.connect(
self.use_collections_template_checkbox_clicked)
self.use_collections_columns_checkbox_clicked(
device.get_pref('use_collections_columns'))
self.use_collections_template_checkbox_clicked(
device.get_pref('use_collections_template'))
def use_collections_columns_checkbox_clicked(self, checked):
self.collections_columns_edit.setEnabled(checked)
def use_collections_template_checkbox_clicked(self, checked):
self.collections_template_edit.setEnabled(checked)
@property
def manage_collections(self):
return self.isChecked()
@property
def use_collections_columns(self):
return self.use_collections_columns_checkbox.isChecked()
@property
def collections_columns(self):
return self.collections_columns_edit.text().strip()
@property
def use_collections_template(self):
return self.use_collections_template_checkbox.isChecked()
@property
def collections_template(self):
return self.collections_template_edit.template
@property
def create_collections(self):
return self.create_collections_checkbox.isChecked()
@property
def delete_empty_collections(self):
return self.delete_empty_collections_checkbox.isChecked()
@property
def ignore_collections_names(self):
return self.ignore_collections_names_edit.text().strip()
