def genesis(self):
self.prev_lname = self.last_lname = ''
self.count_changed(0)
self.action_choose = self.menuless_qaction
self.action_exim = ac = QAction(_('Export/import all calibre data'),
self.gui)
ac.triggered.connect(self.exim_data)
self.stats = LibraryUsageStats()
self.popup_type = (QToolButton.ToolButtonPopupMode.InstantPopup
if len(self.stats.stats) > 1 else
QToolButton.ToolButtonPopupMode.MenuButtonPopup)
if len(self.stats.stats) > 1:
self.action_choose.triggered.connect(self.choose_library)
else:
self.qaction.triggered.connect(self.choose_library)
self.choose_menu = self.qaction.menu()
ac = self.create_action(spec=(_('Pick a random book'), 'random.png',
None, None),
attr='action_pick_random')
ac.triggered.connect(self.pick_random)
self.choose_library_icon_menu = QMenu(
_('Change the icon for this library'))
self.choose_library_icon_menu.setIcon(QIcon(I('icon_choose.png')))
self.choose_library_icon_action = self.create_action(
spec=(_('Choose an icon'), 'icon_choose.png', None, None),
attr='action_choose_library_icon')
self.remove_library_icon_action = self.create_action(
spec=(_('Remove current icon'), 'trash.png', None, None),
attr='action_remove_library_icon')
self.choose_library_icon_action.triggered.connect(
self.get_library_icon)
self.remove_library_icon_action.triggered.connect(
partial(self.remove_library_icon, ''))
self.choose_library_icon_menu.addAction(
self.choose_library_icon_action)
self.choose_library_icon_menu.addAction(
self.remove_library_icon_action)
self.original_library_icon = library_qicon.default_icon = self.qaction.icon(
)
if not os.environ.get('CALIBRE_OVERRIDE_DATABASE_PATH', None):
self.choose_menu.addAction(self.action_choose)
self.quick_menu = QMenu(_('Quick switch'))
self.quick_menu_action = self.choose_menu.addMenu(self.quick_menu)
self.choose_menu.addMenu(self.choose_library_icon_menu)
self.rename_menu = QMenu(_('Rename library'))
self.rename_menu_action = self.choose_menu.addMenu(
self.rename_menu)
self.choose_menu.addAction(ac)
self.delete_menu = QMenu(_('Remove library'))
self.delete_menu_action = self.choose_menu.addMenu(
self.delete_menu)
self.vl_to_apply_menu = QMenu('waiting ...')
self.vl_to_apply_action = self.choose_menu.addMenu(
self.vl_to_apply_menu)
self.rebuild_change_library_menus.connect(
self.build_menus, type=Qt.ConnectionType.QueuedConnection)
self.choose_menu.addAction(self.action_exim)
else:
self.choose_menu.addMenu(self.choose_library_icon_menu)
self.choose_menu.addAction(ac)
self.rename_separator = self.choose_menu.addSeparator()
self.switch_actions = []
for i in range(5):
ac = self.create_action(spec=('', None, None, None),
attr='switch_action%d' % i)
ac.setObjectName(str(i))
self.switch_actions.append(ac)
ac.setVisible(False)
connect_lambda(
ac.triggered,
self,
lambda self: self.switch_requested(self.qs_locations[int(
self.gui.sender().objectName())]),
type=Qt.ConnectionType.QueuedConnection)
self.choose_menu.addAction(ac)
self.rename_separator = self.choose_menu.addSeparator()
self.maintenance_menu = QMenu(_('Library maintenance'))
ac = self.create_action(spec=(_('Library metadata backup status'),
'lt.png', None, None),
attr='action_backup_status')
ac.triggered.connect(self.backup_status,
type=Qt.ConnectionType.QueuedConnection)
self.maintenance_menu.addAction(ac)
ac = self.create_action(spec=(_('Check library'), 'lt.png', None,
None),
attr='action_check_library')
ac.triggered.connect(self.check_library,
type=Qt.ConnectionType.QueuedConnection)
self.maintenance_menu.addAction(ac)
ac = self.create_action(spec=(_('Restore database'), 'lt.png', None,
None),
attr='action_restore_database')
ac.triggered.connect(self.restore_database,
type=Qt.ConnectionType.QueuedConnection)
self.maintenance_menu.addAction(ac)
self.choose_menu.addMenu(self.maintenance_menu)
self.view_state_map = {}
self.restore_view_state.connect(
self._restore_view_state, type=Qt.ConnectionType.QueuedConnection)
ac = self.create_action(spec=(_('Switch to previous library'),
'lt.png', None, None),
attr='action_previous_library')
ac.triggered.connect(self.switch_to_previous_library,
type=Qt.ConnectionType.QueuedConnection)
self.gui.keyboard.register_shortcut(self.unique_name + '-' +
'action_previous_library',
ac.text(),
action=ac,
group=self.action_spec[0],
default_keys=('Ctrl+Alt+p', ))
self.gui.addAction(ac)
def setupUi(self):
self.setObjectName("Dialog")
self.resize(1024, 700)
self.setWindowIcon(QIcon(I('convert.png')))
self.gridLayout = QGridLayout(self)
self.gridLayout.setObjectName("gridLayout")
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.input_label = QLabel(self)
self.input_label.setObjectName("input_label")
self.horizontalLayout.addWidget(self.input_label)
self.input_formats = QComboBox(self)
self.input_formats.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.input_formats.setMinimumContentsLength(5)
self.input_formats.setObjectName("input_formats")
self.horizontalLayout.addWidget(self.input_formats)
self.opt_individual_saved_settings = QCheckBox(self)
self.opt_individual_saved_settings.setObjectName(
"opt_individual_saved_settings")
self.horizontalLayout.addWidget(self.opt_individual_saved_settings)
spacerItem = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.label_2 = QLabel(self)
self.label_2.setObjectName("label_2")
self.horizontalLayout.addWidget(self.label_2)
self.output_formats = QComboBox(self)
self.output_formats.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.output_formats.setMinimumContentsLength(5)
self.output_formats.setObjectName("output_formats")
self.horizontalLayout.addWidget(self.output_formats)
self.gridLayout.addLayout(self.horizontalLayout, 0, 0, 1, 2)
self.groups = QListView(self)
sizePolicy = QSizePolicy(QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Expanding)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.groups.sizePolicy().hasHeightForWidth())
self.groups.setSizePolicy(sizePolicy)
self.groups.setTabKeyNavigation(True)
self.groups.setIconSize(QSize(48, 48))
self.groups.setWordWrap(True)
self.groups.setObjectName("groups")
self.gridLayout.addWidget(self.groups, 1, 0, 3, 1)
self.scrollArea = QScrollArea(self)
sizePolicy = QSizePolicy(QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Expanding)
sizePolicy.setHorizontalStretch(4)
sizePolicy.setVerticalStretch(10)
sizePolicy.setHeightForWidth(
self.scrollArea.sizePolicy().hasHeightForWidth())
self.scrollArea.setSizePolicy(sizePolicy)
self.scrollArea.setFrameShape(QFrame.Shape.NoFrame)
self.scrollArea.setLineWidth(0)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.page = QWidget()
self.page.setObjectName("page")
self.gridLayout.addWidget(self.scrollArea, 1, 1, 1, 1)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
self.buttonBox.setStandardButtons(
QDialogButtonBox.StandardButton.Cancel
| QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.RestoreDefaults)
self.buttonBox.setObjectName("buttonBox")
self.gridLayout.addWidget(self.buttonBox, 3, 1, 1, 1)
self.help = QTextEdit(self)
self.help.setReadOnly(True)
sizePolicy = QSizePolicy(QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.help.sizePolicy().hasHeightForWidth())
self.help.setSizePolicy(sizePolicy)
self.help.setMaximumHeight(80)
self.help.setObjectName("help")
self.gridLayout.addWidget(self.help, 2, 1, 1, 1)
self.input_label.setBuddy(self.input_formats)
self.label_2.setBuddy(self.output_formats)
self.input_label.setText(_("&Input format:"))
self.opt_individual_saved_settings.setText(
_("Use &saved conversion settings for individual books"))
self.label_2.setText(_("&Output format:"))
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def __init__(self, parent):
QWidget.__init__(self, parent)
self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
parent = parent.parent()
self.l = l = QHBoxLayout(self)
l.setContentsMargins(0, 0, 0, 0)
self.alter_tb = parent.alter_tb = b = QToolButton(self)
b.setAutoRaise(True)
b.setText(_('Configure')), b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
b.setCursor(Qt.CursorShape.PointingHandCursor)
b.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
b.setToolTip(textwrap.fill(_(
'Change how the Tag browser works, such as,'
' how it is sorted, what happens when you click'
' items, etc.'
)))
b.setIcon(QIcon(I('config.png')))
b.m = QMenu(b)
b.setMenu(b.m)
self.item_search = FindBox(parent)
self.item_search.setMinimumContentsLength(5)
self.item_search.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.item_search.initialize('tag_browser_search')
self.item_search.completer().setCaseSensitivity(Qt.CaseSensitivity.CaseSensitive)
self.item_search.setToolTip(
'<p>' +_(
'Search for items. If the text begins with equals (=) the search is '
'exact match, otherwise it is "contains" finding items containing '
'the text anywhere in the item name. Both exact and contains '
'searches ignore case. You can limit the search to particular '
'categories using syntax similar to search. For example, '
'tags:foo will find foo in any tag, but not in authors etc. Entering '
'*foo will collapse all categories then showing only those categories '
'with items containing the text "foo"') + '</p>')
ac = QAction(parent)
parent.addAction(ac)
parent.keyboard.register_shortcut('tag browser find box',
_('Find in the Tag browser'), default_keys=(),
action=ac, group=_('Tag browser'))
ac.triggered.connect(self.set_focus_to_find_box)
self.search_button = QToolButton()
self.search_button.setAutoRaise(True)
self.search_button.setCursor(Qt.CursorShape.PointingHandCursor)
self.search_button.setIcon(QIcon(I('search.png')))
self.search_button.setToolTip(_('Find the first/next matching item'))
ac = QAction(parent)
parent.addAction(ac)
parent.keyboard.register_shortcut('tag browser find button',
_('Find next match'), default_keys=(),
action=ac, group=_('Tag browser'))
ac.triggered.connect(self.search_button.click)
self.toggle_search_button = b = QToolButton(self)
le = self.item_search.lineEdit()
le.addAction(QIcon(I('window-close.png')), QLineEdit.ActionPosition.LeadingPosition).triggered.connect(self.close_find_box)
b.setText(_('Find')), b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
b.setCursor(Qt.CursorShape.PointingHandCursor)
b.setIcon(QIcon(I('search.png')))
b.setCheckable(True)
b.setChecked(gprefs.get('tag browser search box visible', False))
b.setToolTip(_('Find item in the Tag browser'))
b.setAutoRaise(True)
b.toggled.connect(self.update_searchbar_state)
self.update_searchbar_state()
def __init__(self, parent):
QWidget.__init__(self, parent)
self.l = l = QGridLayout(self)
l.setContentsMargins(0, 0, 0, 0)
self.setLayout(l)
self.bookmarks_list = bl = BookmarksList(self)
bl.itemChanged.connect(self.item_changed)
l.addWidget(bl, 0, 0, 1, -1)
bl.itemClicked.connect(self.item_activated)
bl.bookmark_activated.connect(self.item_activated)
bl.changed.connect(lambda: self.edited.emit(self.get_bookmarks()))
bl.ac_edit.triggered.connect(self.edit_bookmark)
bl.ac_delete.triggered.connect(self.delete_bookmark)
self.la = la = QLabel(_('Double click to edit the bookmarks'))
la.setWordWrap(True)
l.addWidget(la, l.rowCount(), 0, 1, -1)
self.button_new = b = QPushButton(QIcon(I('bookmarks.png')), _('&New'),
self)
b.clicked.connect(self.create_requested)
b.setToolTip(_('Create a new bookmark at the current location'))
l.addWidget(b)
self.button_delete = b = QPushButton(QIcon(I('trash.png')),
_('&Remove'), self)
b.setToolTip(_('Remove the currently selected bookmark'))
b.clicked.connect(self.delete_bookmark)
l.addWidget(b, l.rowCount() - 1, 1)
self.button_prev = b = QPushButton(QIcon(I('back.png')),
_('Pre&vious'), self)
b.clicked.connect(self.bookmarks_list.previous_bookmark)
l.addWidget(b)
self.button_next = b = QPushButton(QIcon(I('forward.png')), _('Nex&t'),
self)
b.clicked.connect(self.bookmarks_list.next_bookmark)
l.addWidget(b, l.rowCount() - 1, 1)
la = QLabel(_('&Sort by:'))
self.sort_by = sb = QComboBox(self)
la.setBuddy(sb)
sb.addItem(_('Title'), 'title')
sb.addItem(_('Position in book'), 'pos')
sb.addItem(_('Date'), 'timestamp')
sb.setToolTip(_('Change how the bookmarks are sorted'))
i = sb.findData(vprefs['bookmarks_sort'])
if i > -1:
sb.setCurrentIndex(i)
h = QHBoxLayout()
h.addWidget(la), h.addWidget(sb, 10)
l.addLayout(h, l.rowCount(), 0, 1, 2)
sb.currentIndexChanged.connect(self.sort_by_changed)
self.button_export = b = QPushButton(_('E&xport'), self)
b.clicked.connect(self.export_bookmarks)
l.addWidget(b, l.rowCount(), 0)
self.button_import = b = QPushButton(_('&Import'), self)
b.clicked.connect(self.import_bookmarks)
l.addWidget(b, l.rowCount() - 1, 1)
def __init__(self, parent, prefs):
QWidget.__init__(self, parent)
self.toc_title = None
self.prefs = prefs
l = self.l = QGridLayout()
self.setLayout(l)
self.tocw = t = TreeWidget(self)
self.tocw.edit_item.connect(self.edit_item)
l.addWidget(t, 0, 0, 7, 3)
self.up_button = b = QToolButton(self)
b.setIcon(QIcon(I('arrow-up.png')))
b.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
l.addWidget(b, 0, 3)
b.setToolTip(_('Move current entry up [Ctrl+Up]'))
b.clicked.connect(self.move_up)
self.left_button = b = QToolButton(self)
b.setIcon(QIcon(I('back.png')))
b.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
l.addWidget(b, 2, 3)
b.setToolTip(_('Unindent the current entry [Ctrl+Left]'))
b.clicked.connect(self.tocw.move_left)
self.del_button = b = QToolButton(self)
b.setIcon(QIcon(I('trash.png')))
b.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
l.addWidget(b, 3, 3)
b.setToolTip(_('Remove all selected entries'))
b.clicked.connect(self.del_items)
self.right_button = b = QToolButton(self)
b.setIcon(QIcon(I('forward.png')))
b.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
l.addWidget(b, 4, 3)
b.setToolTip(_('Indent the current entry [Ctrl+Right]'))
b.clicked.connect(self.tocw.move_right)
self.down_button = b = QToolButton(self)
b.setIcon(QIcon(I('arrow-down.png')))
b.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
l.addWidget(b, 6, 3)
b.setToolTip(_('Move current entry down [Ctrl+Down]'))
b.clicked.connect(self.move_down)
self.expand_all_button = b = QPushButton(_('&Expand all'))
col = 7
l.addWidget(b, col, 0)
b.clicked.connect(self.tocw.expandAll)
self.collapse_all_button = b = QPushButton(_('&Collapse all'))
b.clicked.connect(self.tocw.collapseAll)
l.addWidget(b, col, 1)
self.default_msg = _('Double click on an entry to change the text')
self.hl = hl = QLabel(self.default_msg)
hl.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
l.addWidget(hl, col, 2, 1, -1)
self.item_view = i = ItemView(self, self.prefs)
self.item_view.delete_item.connect(self.delete_current_item)
i.add_new_item.connect(self.add_new_item)
i.create_from_xpath.connect(self.create_from_xpath)
i.create_from_links.connect(self.create_from_links)
i.create_from_files.connect(self.create_from_files)
i.flatten_item.connect(self.flatten_item)
i.flatten_toc.connect(self.flatten_toc)
i.go_to_root.connect(self.go_to_root)
l.addWidget(i, 0, 4, col, 1)
l.setColumnStretch(2, 10)
def __init__(self,
parent,
current_img,
current_url,
geom_name='viewer_image_popup_geometry',
prefs=gprefs):
QDialog.__init__(self)
self.prefs = prefs
self.current_image_name = ''
self.maximized_at_last_fullscreen = False
self.setWindowFlag(Qt.WindowType.WindowMinimizeButtonHint)
self.setWindowFlag(Qt.WindowType.WindowMaximizeButtonHint)
self.avail_geom = self.screen().availableGeometry()
self.current_img = current_img
self.current_url = current_url
self.factor = 1.0
self.geom_name = geom_name
self.scrollarea = sa = ScrollArea()
sa.setAlignment(Qt.AlignmentFlag.AlignHCenter
| Qt.AlignmentFlag.AlignVCenter)
sa.setBackgroundRole(QPalette.ColorRole.Dark)
self.label = l = Label(sa)
l.zoom_requested.connect(self.zoom_requested)
sa.toggle_fit.connect(self.toggle_fit)
sa.setWidget(l)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
self.zi_button = zi = bb.addButton(
_('Zoom &in'), QDialogButtonBox.ButtonRole.ActionRole)
self.zo_button = zo = bb.addButton(
_('Zoom &out'), QDialogButtonBox.ButtonRole.ActionRole)
self.save_button = so = bb.addButton(
_('&Save as'), QDialogButtonBox.ButtonRole.ActionRole)
self.copy_button = co = bb.addButton(
_('&Copy'), QDialogButtonBox.ButtonRole.ActionRole)
self.rotate_button = ro = bb.addButton(
_('&Rotate'), QDialogButtonBox.ButtonRole.ActionRole)
self.fullscreen_button = fo = bb.addButton(
_('&Full screen'), QDialogButtonBox.ButtonRole.ActionRole)
zi.setIcon(QIcon(I('plus.png')))
zo.setIcon(QIcon(I('minus.png')))
so.setIcon(QIcon(I('save.png')))
co.setIcon(QIcon.ic('edit-copy.png'))
ro.setIcon(QIcon(I('rotate-right.png')))
fo.setIcon(QIcon(I('page.png')))
zi.clicked.connect(self.zoom_in)
zo.clicked.connect(self.zoom_out)
so.clicked.connect(self.save_image)
co.clicked.connect(self.copy_image)
self.copy_action = QAction(self)
self.addAction(self.copy_action)
self.copy_action.triggered.connect(self.copy_button.click)
self.copy_action.setShortcut(QKeySequence.StandardKey.Copy)
ro.clicked.connect(self.rotate_image)
fo.setCheckable(True)
self.l = l = QVBoxLayout(self)
l.addWidget(sa)
self.h = h = QHBoxLayout()
h.setContentsMargins(0, 0, 0, 0)
l.addLayout(h)
self.fit_image = i = QCheckBox(_('&Fit image'))
i.setToolTip(_('Fit image inside the available space'))
i.setChecked(bool(self.prefs.get('image_popup_fit_image')))
i.stateChanged.connect(self.fit_changed)
h.addWidget(i), h.addStretch(), h.addWidget(bb)
if self.fit_image.isChecked():
self.set_to_viewport_size()
geom = self.prefs.get(self.geom_name)
if geom is not None:
self.restoreGeometry(geom)
fo.setChecked(self.isFullScreen())
fo.toggled.connect(self.toggle_fullscreen)
def setup_ui(self):
self.vl = vl = QVBoxLayout(self)
self.stack = l = QStackedLayout()
self.pi = pi = ProgressIndicator(self, 256)
vl.addLayout(l), vl.addWidget(self.bb)
self.restore_defs_button = b = self.bb.addButton(
_('Restore &default icons'),
QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.restore_defaults)
b.setIcon(QIcon(I('view-refresh.png')))
self.c = c = QWidget(self)
self.c.v = v = QVBoxLayout(self.c)
v.addStretch(), v.addWidget(pi, 0, Qt.AlignmentFlag.AlignCenter)
self.wait_msg = m = QLabel(self)
v.addWidget(m, 0, Qt.AlignmentFlag.AlignCenter), v.addStretch()
f = m.font()
f.setBold(True), f.setPointSize(28), m.setFont(f)
self.start_spinner()
l.addWidget(c)
self.w = w = QWidget(self)
l.addWidget(w)
w.l = l = QGridLayout(w)
def add_row(x, y=None):
if isinstance(x, unicode_type):
x = QLabel(x)
row = l.rowCount()
if y is None:
if isinstance(x, QLabel):
x.setWordWrap(True)
l.addWidget(x, row, 0, 1, 2)
else:
if isinstance(x, QLabel):
x.setBuddy(y)
l.addWidget(x, row, 0), l.addWidget(y, row, 1)
add_row(
_('Choose an icon theme below. You will need to restart'
' calibre to see the new icons.'))
add_row(
_('Current icon theme:') + '\xa0<b>' +
(self.current_theme or 'None'))
self.sort_by = sb = QComboBox(self)
add_row(_('&Sort by:'), sb)
sb.addItems([
_('Number of icons'),
_('Popularity'),
_('Name'),
])
sb.setEditable(False), sb.setCurrentIndex(
gprefs.get('choose_icon_theme_sort_by', 1))
sb.currentIndexChanged[int].connect(self.re_sort)
sb.currentIndexChanged[int].connect(
lambda: gprefs.set('choose_icon_theme_sort_by', sb.currentIndex()))
self.theme_list = tl = QListWidget(self)
tl.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
self.delegate = Delegate(tl)
tl.setItemDelegate(self.delegate)
tl.itemDoubleClicked.connect(self.accept)
add_row(tl)
t = Thread(name='GetIconThemes', target=self.get_themes)
t.daemon = True
t.start()
def __init__(self,
mi=None,
prefs=None,
parent=None,
for_global_prefs=False):
QWidget.__init__(self, parent)
self.ignore_changed = False
self.for_global_prefs = for_global_prefs
self.l = l = QHBoxLayout(self)
l.setContentsMargins(0, 0, 0, 0)
self.setLayout(l)
self.settings_tabs = st = QTabWidget(self)
l.addWidget(st)
self.preview_label = la = Preview(self)
l.addWidget(la)
if prefs is None:
prefs = cprefs
self.original_prefs = prefs
self.mi = mi or self.default_mi()
self.colors_page = cp = QWidget(st)
st.addTab(cp, _('&Colors'))
cp.l = l = QGridLayout()
cp.setLayout(l)
if for_global_prefs:
msg = _(
'When generating covers, a color scheme for the cover is chosen at random from the'
' color schemes below. You can prevent an individual scheme from being selected by'
' unchecking it. The preview on the right shows the currently selected color scheme.'
)
else:
msg = _(
'Choose a color scheme to be used for this generated cover.'
) + '<p>' + _(
'In normal cover generation, the color scheme is chosen at random from the list of color schemes below. You'
' can prevent an individual color scheme from being chosen by unchecking it here.'
)
cp.la = la = QLabel('<p>' + msg)
la.setWordWrap(True)
l.addWidget(la, 0, 0, 1, -1)
self.colors_list = cl = QListWidget(cp)
l.addWidget(cl, 1, 0, 1, -1)
self.colors_map = OrderedDict()
self.ncs = ncs = QPushButton(QIcon(I('plus.png')),
_('&New color scheme'), cp)
ncs.clicked.connect(self.create_color_scheme)
l.addWidget(ncs)
self.ecs = ecs = QPushButton(QIcon(I('format-fill-color.png')),
_('&Edit color scheme'), cp)
ecs.clicked.connect(self.edit_color_scheme)
l.addWidget(ecs, l.rowCount() - 1, 1)
self.rcs = rcs = QPushButton(QIcon(I('minus.png')),
_('&Remove color scheme'), cp)
rcs.clicked.connect(self.remove_color_scheme)
l.addWidget(rcs, l.rowCount() - 1, 2)
self.styles_page = sp = QWidget(st)
st.addTab(sp, _('&Styles'))
sp.l = l = QVBoxLayout()
sp.setLayout(l)
if for_global_prefs:
msg = _(
'When generating covers, a style for the cover is chosen at random from the'
' styles below. You can prevent an individual style from being selected by'
' unchecking it. The preview on the right shows the currently selected style.'
)
else:
msg = _(
'Choose a style to be used for this generated cover.'
) + '<p>' + _(
'In normal cover generation, the style is chosen at random from the list of styles below. You'
' can prevent an individual style from being chosen by unchecking it here.'
)
sp.la = la = QLabel('<p>' + msg)
la.setWordWrap(True)
l.addWidget(la)
self.styles_list = sl = QListWidget(sp)
l.addWidget(sl)
self.style_map = OrderedDict()
self.font_page = fp = QWidget(st)
st.addTab(fp, _('&Fonts and sizes'))
fp.l = l = QFormLayout()
fp.setLayout(l)
fp.f = []
def add_hline():
f = QFrame()
fp.f.append(f)
f.setFrameShape(QFrame.Shape.HLine)
l.addRow(f)
for x, label, size_label in (
('title', _('&Title font family:'), _('&Title font size:')),
('subtitle', _('&Subtitle font family:'),
_('&Subtitle font size:')),
('footer', _('&Footer font family:'), _('&Footer font size:')),
):
attr = '%s_font_family' % x
ff = FontFamilyChooser(fp)
setattr(self, attr, ff)
l.addRow(label, ff)
ff.family_changed.connect(self.emit_changed)
attr = '%s_font_size' % x
fs = QSpinBox(fp)
setattr(self, attr, fs)
fs.setMinimum(8), fs.setMaximum(200), fs.setSuffix(' px')
fs.setValue(prefs[attr])
fs.valueChanged.connect(self.emit_changed)
l.addRow(size_label, fs)
add_hline()
self.changed_timer = t = QTimer(self)
t.setSingleShot(True), t.setInterval(500), t.timeout.connect(
self.emit_changed)
def create_sz(label):
ans = QSpinBox(self)
ans.setSuffix(' px'), ans.setMinimum(100), ans.setMaximum(10000)
l.addRow(label, ans)
ans.valueChanged.connect(self.changed_timer.start)
return ans
self.cover_width = create_sz(_('Cover &width:'))
self.cover_height = create_sz(_('Cover &height:'))
fp.cla = la = QLabel(
_('Note that the preview to the side is of fixed aspect ratio, so changing the cover'
' width above will not have any effect. If you change the height, you should also change the width nevertheless'
' as it will be used in actual cover generation.'))
la.setWordWrap(True)
l.addRow(la)
self.templates_page = tp = QWidget(st)
st.addTab(tp, _('&Text'))
tp.l = l = QVBoxLayout()
tp.setLayout(l)
tp.la = la = QLabel(
_('The text on the generated cover is taken from the metadata of the book.'
' This is controlled via templates. You can use the <b>, <i> and <br> tags'
' in the templates for bold, italic and line breaks, respectively. The'
' default templates use the title, series and authors. You can change them to use'
' whatever metadata you like.'))
la.setWordWrap(True), la.setTextFormat(Qt.TextFormat.PlainText)
l.addWidget(la)
def create_template_widget(title, which, button):
attr = which + '_template'
heading = QLabel('<h2>' + title)
setattr(tp, attr + '_heading', heading)
l.addWidget(heading)
la = QLabel()
setattr(self, attr, la)
l.addWidget(la), la.setTextFormat(
Qt.TextFormat.PlainText), la.setStyleSheet(
'QLabel {font-family: monospace}')
la.setWordWrap(True)
b = QPushButton(button)
b.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
connect_lambda(b.clicked, self,
lambda self: self.change_template(which))
setattr(self, attr + '_button', b)
l.addWidget(b)
if which != 'footer':
f = QFrame(tp)
setattr(tp, attr + '_sep',
f), f.setFrameShape(QFrame.Shape.HLine)
l.addWidget(f)
l.addSpacing(10)
create_template_widget(_('The title template'), 'title',
_('Change the &title template'))
create_template_widget(_('The sub-title template'), 'subtitle',
_('Change the &sub-title template'))
create_template_widget(_('The footer template'), 'footer',
_('Change the &footer template'))
l.addStretch(2)
self.apply_prefs(prefs)
self.changed.connect(self.update_preview)
self.styles_list.itemSelectionChanged.connect(self.update_preview)
self.colors_list.itemSelectionChanged.connect(self.update_preview)
self.update_preview()
def update_display(self):
self.pix.fill(self._color)
self.setIcon(QIcon(self.pix))
def link(text, url):
def doit():
QApplication.instance().clipboard().setText(url)
menu.addAction(QIcon(I('edit-copy.png')), text, doit)
def __init__(self,
parent,
db,
id_to_select,
select_sort,
select_link,
find_aut_func,
is_first_letter=False):
QDialog.__init__(self, parent)
Ui_EditAuthorsDialog.__init__(self)
self.setupUi(self)
# Remove help icon on title bar
icon = self.windowIcon()
self.setWindowFlags(self.windowFlags()
& (~Qt.WindowType.WindowContextHelpButtonHint))
self.setWindowIcon(icon)
try:
self.table_column_widths = \
gprefs.get('manage_authors_table_widths', None)
geom = gprefs.get('manage_authors_dialog_geometry', None)
if geom:
QApplication.instance().safe_restore_geometry(
self, QByteArray(geom))
except Exception:
pass
self.buttonBox.button(QDialogButtonBox.StandardButton.Ok).setText(
_('&OK'))
self.buttonBox.button(QDialogButtonBox.StandardButton.Cancel).setText(
_('&Cancel'))
self.buttonBox.accepted.connect(self.accepted)
self.apply_vl_checkbox.stateChanged.connect(self.use_vl_changed)
# Set up the heading for sorting
self.table.setSelectionMode(
QAbstractItemView.SelectionMode.SingleSelection)
self.find_aut_func = find_aut_func
self.table.resizeColumnsToContents()
if self.table.columnWidth(2) < 200:
self.table.setColumnWidth(2, 200)
# set up the cellChanged signal only after the table is filled
self.table.cellChanged.connect(self.cell_changed)
self.recalc_author_sort.clicked.connect(self.do_recalc_author_sort)
self.auth_sort_to_author.clicked.connect(self.do_auth_sort_to_author)
# Capture clicks on the horizontal header to sort the table columns
hh = self.table.horizontalHeader()
hh.sectionResized.connect(self.table_column_resized)
hh.setSectionsClickable(True)
hh.sectionClicked.connect(self.do_sort)
hh.setSortIndicatorShown(True)
# set up the search & filter boxes
self.find_box.initialize('manage_authors_search')
le = self.find_box.lineEdit()
ac = le.findChild(QAction, QT_HIDDEN_CLEAR_ACTION)
if ac is not None:
ac.triggered.connect(self.clear_find)
le.returnPressed.connect(self.do_find)
self.find_box.editTextChanged.connect(self.find_text_changed)
self.find_button.clicked.connect(self.do_find)
self.find_button.setDefault(True)
self.filter_box.initialize('manage_authors_filter')
le = self.filter_box.lineEdit()
ac = le.findChild(QAction, QT_HIDDEN_CLEAR_ACTION)
if ac is not None:
ac.triggered.connect(self.clear_filter)
self.filter_box.lineEdit().returnPressed.connect(self.do_filter)
self.filter_button.clicked.connect(self.do_filter)
self.not_found_label = l = QLabel(self.table)
l.setFrameStyle(QFrame.Shape.StyledPanel)
l.setAutoFillBackground(True)
l.setText(_('No matches found'))
l.setAlignment(Qt.AlignmentFlag.AlignVCenter)
l.resize(l.sizeHint())
l.move(10, 2)
l.setVisible(False)
self.not_found_label_timer = QTimer()
self.not_found_label_timer.setSingleShot(True)
self.not_found_label_timer.timeout.connect(
self.not_found_label_timer_event,
type=Qt.ConnectionType.QueuedConnection)
self.table.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.show_context_menu)
# Fetch the data
self.authors = {}
self.original_authors = {}
auts = db.new_api.author_data()
self.completion_data = []
for id_, v in auts.items():
name = v['name']
name = name.replace('|', ',')
self.completion_data.append(name)
self.authors[id_] = {
'name': name,
'sort': v['sort'],
'link': v['link']
}
self.original_authors[id_] = {
'name': name,
'sort': v['sort'],
'link': v['link']
}
self.edited_icon = QIcon(I('modified.png'))
self.empty_icon = QIcon()
if prefs['use_primary_find_in_search']:
self.string_contains = primary_contains
else:
self.string_contains = contains
self.last_sorted_by = 'sort'
self.author_order = 1
self.author_sort_order = 0
self.link_order = 1
self.show_table(id_to_select, select_sort, select_link,
is_first_letter)
def add_copy_action(name):
copy_menu.addAction(
QIcon(I('edit-copy.png')),
_('The text: {}').format(name),
lambda: QApplication.instance().clipboard().setText(name))
def build_menus(self):
if os.environ.get('CALIBRE_OVERRIDE_DATABASE_PATH', None):
return
db = self.gui.library_view.model().db
lname = self.stats.library_used(db)
self.vl_to_apply_action.setText(
_('Apply Virtual library when %s is opened') % lname)
locations = list(self.stats.locations(db))
for ac in self.switch_actions:
ac.setVisible(False)
self.quick_menu.clear()
self.rename_menu.clear()
self.delete_menu.clear()
quick_actions, rename_actions, delete_actions = [], [], []
for name, loc in locations:
is_prev_lib = name == self.prev_lname
ic = library_qicon(name)
name = name.replace('&', '&&')
ac = self.quick_menu.addAction(
ic, name, Dispatcher(partial(self.switch_requested, loc)))
ac.setStatusTip(_('Switch to: %s') % loc)
if is_prev_lib:
f = ac.font()
f.setBold(True)
ac.setFont(f)
quick_actions.append(ac)
ac = self.rename_menu.addAction(
name, Dispatcher(partial(self.rename_requested, name, loc)))
rename_actions.append(ac)
ac.setStatusTip(_('Rename: %s') % loc)
ac = self.delete_menu.addAction(
name, Dispatcher(partial(self.delete_requested, name, loc)))
delete_actions.append(ac)
ac.setStatusTip(_('Remove: %s') % loc)
if is_prev_lib:
ac.setFont(f)
qs_actions = []
locations_by_frequency = locations
if len(locations) >= tweaks['many_libraries']:
locations_by_frequency = list(
self.stats.locations(db, limit=sys.maxsize))
for i, x in enumerate(
locations_by_frequency[:len(self.switch_actions)]):
name, loc = x
ic = library_qicon(name)
name = name.replace('&', '&&')
ac = self.switch_actions[i]
ac.setText(name)
ac.setIcon(ic)
ac.setStatusTip(_('Switch to: %s') % loc)
ac.setVisible(True)
qs_actions.append(ac)
self.qs_locations = [i[1] for i in locations_by_frequency]
self.quick_menu_action.setVisible(bool(locations))
self.rename_menu_action.setVisible(bool(locations))
self.delete_menu_action.setVisible(bool(locations))
self.gui.location_manager.set_switch_actions(quick_actions,
rename_actions,
delete_actions,
qs_actions,
self.action_choose)
# VL at startup
self.vl_to_apply_menu.clear()
restrictions = sorted(db.prefs['virtual_libraries'], key=sort_key)
# check that the virtual library choice still exists
vl_at_startup = db.prefs['virtual_lib_on_startup']
if vl_at_startup and vl_at_startup not in restrictions:
vl_at_startup = db.prefs['virtual_lib_on_startup'] = ''
restrictions.insert(0, '')
for vl in restrictions:
if vl == vl_at_startup:
self.vl_to_apply_menu.addAction(
QIcon(I('ok.png')), vl if vl else _('No Virtual library'),
Dispatcher(partial(self.change_vl_at_startup_requested,
vl)))
else:
self.vl_to_apply_menu.addAction(
vl if vl else _('No Virtual library'),
Dispatcher(partial(self.change_vl_at_startup_requested,
vl)))
# Allow the cloned actions in the OS X global menubar to update
for a in (self.qaction, self.menuless_qaction):
a.changed.emit()
def library_qicon(lib_name=''):
q = library_icon_path(lib_name)
if os.path.exists(q):
return QIcon(q)
return getattr(library_qicon, 'default_icon', None) or QIcon.ic('lt.png')
def setupUi(self, x):
self.l = l = QVBoxLayout(self)
self.la1 = la = QLabel(
_("Values for the tweaks are shown below. Edit them to change the behavior of calibre."
" Your changes will only take effect <b>after a restart</b> of calibre."
))
l.addWidget(la), la.setWordWrap(True)
self.splitter = s = QSplitter(self)
s.setChildrenCollapsible(False)
l.addWidget(s, 10)
self.lv = lv = QWidget(self)
lv.l = l2 = QVBoxLayout(lv)
l2.setContentsMargins(0, 0, 0, 0)
self.tweaks_view = tv = TweaksView(self)
l2.addWidget(tv)
self.plugin_tweaks_button = b = QPushButton(self)
b.setToolTip(
_("Edit tweaks for any custom plugins you have installed"))
b.setText(_("&Plugin tweaks"))
l2.addWidget(b)
s.addWidget(lv)
self.lv1 = lv = QWidget(self)
s.addWidget(lv)
lv.g = g = QGridLayout(lv)
g.setContentsMargins(0, 0, 0, 0)
self.search = sb = SearchBox2(self)
sb.sizePolicy().setHorizontalStretch(10)
sb.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLength)
sb.setMinimumContentsLength(10)
g.setColumnStretch(0, 100)
g.addWidget(self.search, 0, 0, 1, 1)
self.next_button = b = QPushButton(self)
b.setIcon(QIcon(I("arrow-down.png")))
b.setText(_("&Next"))
g.addWidget(self.next_button, 0, 1, 1, 1)
self.previous_button = b = QPushButton(self)
b.setIcon(QIcon(I("arrow-up.png")))
b.setText(_("&Previous"))
g.addWidget(self.previous_button, 0, 2, 1, 1)
self.hb = hb = QGroupBox(self)
hb.setTitle(_("Help"))
hb.l = l2 = QVBoxLayout(hb)
self.help = h = QPlainTextEdit(self)
l2.addWidget(h)
h.setReadOnly(True)
g.addWidget(hb, 1, 0, 1, 3)
self.eb = eb = QGroupBox(self)
g.addWidget(eb, 2, 0, 1, 3)
eb.setTitle(_("Edit tweak"))
eb.g = ebg = QGridLayout(eb)
self.edit_tweak = et = QPlainTextEdit(self)
et.setMinimumWidth(400)
et.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
ebg.addWidget(et, 0, 0, 1, 2)
self.restore_default_button = b = QPushButton(self)
b.setToolTip(_("Restore this tweak to its default value"))
b.setText(_("&Reset this tweak"))
ebg.addWidget(b, 1, 0, 1, 1)
self.apply_button = ab = QPushButton(self)
ab.setToolTip(_("Apply any changes you made to this tweak"))
ab.setText(_("&Apply changes to this tweak"))
ebg.addWidget(ab, 1, 1, 1, 1)
def init_layout_mixin(self):
self.vl_tabs = VLTabs(self)
self.centralwidget.layout().addWidget(self.vl_tabs)
if config['gui_layout'] == 'narrow': # narrow {{{
self.book_details = BookDetails(False, self)
self.stack = Stack(self)
self.bd_splitter = Splitter('book_details_splitter',
_('Book details'),
I('book.png'),
orientation=Qt.Orientation.Vertical,
parent=self,
side_index=1,
shortcut='Shift+Alt+D')
self.bd_splitter.addWidget(self.stack)
self.bd_splitter.addWidget(self.book_details)
self.bd_splitter.setCollapsible(self.bd_splitter.other_index,
False)
self.centralwidget.layout().addWidget(self.bd_splitter)
button_order = ('sb', 'tb', 'bd', 'gv', 'cb', 'qv')
# }}}
else: # wide {{{
self.bd_splitter = Splitter('book_details_splitter',
_('Book details'),
I('book.png'),
initial_side_size=200,
orientation=Qt.Orientation.Horizontal,
parent=self,
side_index=1,
shortcut='Shift+Alt+D')
self.stack = Stack(self)
self.bd_splitter.addWidget(self.stack)
self.book_details = BookDetails(True, self)
self.bd_splitter.addWidget(self.book_details)
self.bd_splitter.setCollapsible(self.bd_splitter.other_index,
False)
self.bd_splitter.setSizePolicy(
QSizePolicy(QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Expanding))
self.centralwidget.layout().addWidget(self.bd_splitter)
button_order = ('sb', 'tb', 'cb', 'gv', 'qv', 'bd')
# }}}
# This must use the base method to find the plugin because it hasn't
# been fully initialized yet
self.qv = find_plugin('Quickview')
if self.qv and self.qv.actual_plugin_:
self.qv = self.qv.actual_plugin_
self.status_bar = StatusBar(self)
stylename = str(self.style().objectName())
self.grid_view_button = GridViewButton(self)
self.search_bar_button = SearchBarButton(self)
self.grid_view_button.toggled.connect(self.toggle_grid_view)
self.search_bar_button.toggled.connect(self.toggle_search_bar)
self.layout_buttons = []
for x in button_order:
if hasattr(self, x + '_splitter'):
button = getattr(self, x + '_splitter').button
else:
if x == 'gv':
button = self.grid_view_button
elif x == 'qv':
if self.qv is None:
continue
button = self.qv.qv_button
else:
button = self.search_bar_button
self.layout_buttons.append(button)
button.setVisible(False)
if ismacos and stylename != 'Calibre':
button.setStyleSheet('''
QToolButton { background: none; border:none; padding: 0px; }
QToolButton:checked { background: rgba(0, 0, 0, 25%); }
''')
self.status_bar.addPermanentWidget(button)
if gprefs['show_layout_buttons']:
for b in self.layout_buttons:
b.setVisible(True)
self.status_bar.addPermanentWidget(b)
else:
self.layout_button = b = QToolButton(self)
b.setAutoRaise(True), b.setCursor(
Qt.CursorShape.PointingHandCursor)
b.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
b.setText(_('Layout')), b.setIcon(QIcon(I('config.png')))
b.setMenu(LayoutMenu(self))
b.setToolTip(
_('Show and hide various parts of the calibre main window'))
self.status_bar.addPermanentWidget(b)
self.status_bar.addPermanentWidget(self.jobs_button)
self.setStatusBar(self.status_bar)
self.status_bar.update_label.linkActivated.connect(
self.update_link_clicked)
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 __init__(self, parent, mi, op_label, op_value, locals_, line_number):
super().__init__(parent)
self.mi = mi
self.setModal(True)
l = QVBoxLayout(self)
t = self.table = QTableWidget(self)
t.setColumnCount(2)
t.setHorizontalHeaderLabels((_('Name'), _('Value')))
t.setRowCount(2)
l.addWidget(t)
self.table_column_widths = None
try:
self.table_column_widths = \
gprefs.get('template_editor_break_table_widths', None)
t.setColumnWidth(0, self.table_column_widths[0])
except:
t.setColumnWidth(0, t.fontMetrics().averageCharWidth() * 20)
t.horizontalHeader().sectionResized.connect(self.table_column_resized)
t.horizontalHeader().setStretchLastSection(True)
bb = QDialogButtonBox()
b = bb.addButton(_('&Continue'),
QDialogButtonBox.ButtonRole.AcceptRole)
b.setIcon(QIcon(I('sync-right.png')))
b.setToolTip(_('Continue running the template'))
b.setDefault(True)
l.addWidget(bb)
b = bb.addButton(_('&Stop'), QDialogButtonBox.ButtonRole.RejectRole)
b.setIcon(QIcon(I('list_remove.png')))
b.setToolTip(_('Stop running the template'))
l.addWidget(bb)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
self.setLayout(l)
self.setWindowTitle(
_('Break: line {0}, Book {1}').format(line_number, self.mi.title))
local_names = sorted(locals_.keys())
rows = len(local_names)
self.table.setRowCount(rows + 2)
self.table.setItem(0, 0, BreakReporterItem(op_label))
self.table.item(0, 0).setToolTip(
_('The name of the template language operation'))
self.table.setItem(0, 1, BreakReporterItem(op_value))
self.mi_combo = QComboBox()
t.setCellWidget(1, 0, self.mi_combo)
self.mi_combo.addItems(self.get_field_keys())
self.mi_combo.setToolTip('Choose a book metadata field to display')
self.mi_combo.setCurrentIndex(-1)
self.mi_combo.currentTextChanged.connect(self.get_field_value)
for i, k in enumerate(local_names):
itm = BreakReporterItem(k)
itm.setToolTip(_('A variable in the template'))
self.table.setItem(i + 2, 0, itm)
itm = BreakReporterItem(locals_[k])
itm.setToolTip(_('The value of the variable'))
self.table.setItem(i + 2, 1, itm)
try:
geom = gprefs.get('template_editor_break_geometry', None)
if geom is not None:
QApplication.instance().safe_restore_geometry(
self, QByteArray(geom))
except Exception:
pass
def __init__(self, icon=None, text=None, shortcut_action=None):
self.icon, self.text, self.shortcut_action = QIcon(
I(icon)), text, shortcut_action
def genesis(self, gui):
self.gui = gui
if not ismacos and not iswindows:
self.label_widget_style.setVisible(False)
self.opt_ui_style.setVisible(False)
db = gui.library_view.model().db
r = self.register
try:
self.icon_theme_title = json.loads(I('icon-theme.json',
data=True))['name']
except Exception:
self.icon_theme_title = _('Default icons')
self.icon_theme.setText(
_('Icon theme: <b>%s</b>') % self.icon_theme_title)
self.commit_icon_theme = None
self.icon_theme_button.clicked.connect(self.choose_icon_theme)
self.default_author_link = DefaultAuthorLink(
self.default_author_link_container)
self.default_author_link.changed_signal.connect(self.changed_signal)
r('gui_layout',
config,
restart_required=True,
choices=[(_('Wide'), 'wide'), (_('Narrow'), 'narrow')])
r('hidpi',
gprefs,
restart_required=True,
choices=[(_('Automatic'), 'auto'), (_('On'), 'on'),
(_('Off'), 'off')])
if ismacos:
self.opt_hidpi.setVisible(False), self.label_hidpi.setVisible(
False)
r('ui_style',
gprefs,
restart_required=True,
choices=[(_('System default'), 'system'),
(_('calibre style'), 'calibre')])
r('book_list_tooltips', gprefs)
r('dnd_merge', gprefs)
r('wrap_toolbar_text', gprefs, restart_required=True)
r('show_layout_buttons', gprefs, restart_required=True)
r('row_numbers_in_book_list', gprefs)
r('tag_browser_old_look', gprefs)
r('tag_browser_hide_empty_categories', gprefs)
r('tag_browser_always_autocollapse', gprefs)
r('tag_browser_show_tooltips', gprefs)
r('tag_browser_allow_keyboard_focus', gprefs)
r('bd_show_cover', gprefs)
r('bd_overlay_cover_size', gprefs)
r('cover_grid_width', gprefs)
r('cover_grid_height', gprefs)
r('cover_grid_cache_size_multiple', gprefs)
r('cover_grid_disk_cache_size', gprefs)
r('cover_grid_spacing', gprefs)
r('cover_grid_show_title', gprefs)
r('tag_browser_show_counts', gprefs)
r('tag_browser_item_padding', gprefs)
r('books_autoscroll_time', gprefs)
r('qv_respects_vls', gprefs)
r('qv_dclick_changes_column', gprefs)
r('qv_retkey_changes_column', gprefs)
r('qv_follows_column', gprefs)
r('cover_flow_queue_length', config, restart_required=True)
r('cover_browser_reflections', gprefs)
r('cover_browser_title_template', db.prefs)
fm = db.field_metadata
r('cover_browser_subtitle_field',
db.prefs,
choices=[(_('No subtitle'), 'none')] + sorted(
(fm[k].get('name'), k)
for k in fm.all_field_keys() if fm[k].get('name')))
r('emblem_size', gprefs)
r('emblem_position',
gprefs,
choices=[(_('Left'), 'left'), (_('Top'), 'top'),
(_('Right'), 'right'), (_('Bottom'), 'bottom')])
r('book_list_extra_row_spacing', gprefs)
r('booklist_grid', gprefs)
r('book_details_comments_heading_pos',
gprefs,
choices=[(_('Never'), 'hide'), (_('Above text'), 'above'),
(_('Beside text'), 'side')])
self.cover_browser_title_template_button.clicked.connect(
self.edit_cb_title_template)
self.id_links_button.clicked.connect(self.edit_id_link_rules)
def get_esc_lang(l):
if l == 'en':
return 'English'
return get_language(l)
lang = get_lang()
if lang is None or lang not in available_translations():
lang = 'en'
items = [(l, get_esc_lang(l)) for l in available_translations()
if l != lang]
if lang != 'en':
items.append(('en', get_esc_lang('en')))
items.sort(key=lambda x: x[1].lower())
choices = [(y, x) for x, y in items]
# Default language is the autodetected one
choices = [(get_language(lang), lang)] + choices
r('language', prefs, choices=choices, restart_required=True)
r('show_avg_rating', config)
r('disable_animations', config)
r('systray_icon', config, restart_required=True)
r('show_splash_screen', gprefs)
r('disable_tray_notification', config)
r('use_roman_numerals_for_series_number', config)
r('separate_cover_flow', config, restart_required=True)
r('cb_fullscreen', gprefs)
r('cb_preserve_aspect_ratio', gprefs)
r('cb_double_click_to_activate', gprefs)
choices = [(_('Off'), 'off'), (_('Small'), 'small'),
(_('Medium'), 'medium'), (_('Large'), 'large')]
r('toolbar_icon_size', gprefs, choices=choices)
choices = [(_('If there is enough room'), 'auto'),
(_('Always'), 'always'), (_('Never'), 'never')]
r('toolbar_text', gprefs, choices=choices)
choices = [(_('Disabled'), 'disable'),
(_('By first letter'), 'first letter'),
(_('Partitioned'), 'partition')]
r('tags_browser_partition_method', gprefs, choices=choices)
r('tags_browser_collapse_at', gprefs)
r('tags_browser_collapse_fl_at', gprefs)
choices = {
k
for k in db.field_metadata.all_field_keys()
if (db.field_metadata[k]['is_category'] and
(db.field_metadata[k]['datatype'] in
['text', 'series', 'enumeration'])
and not db.field_metadata[k]['display'].get('is_names', False))
or (db.field_metadata[k]['datatype'] in ['composite'] and
db.field_metadata[k]['display'].get('make_category', False))
}
choices |= {'search'}
r('tag_browser_dont_collapse',
gprefs,
setting=CommaSeparatedList,
choices=sorted(choices, key=sort_key))
choices -= {'authors', 'publisher', 'formats', 'news', 'identifiers'}
r('categories_using_hierarchy',
db.prefs,
setting=CommaSeparatedList,
choices=sorted(choices, key=sort_key))
fm = db.field_metadata
choices = sorted(
((fm[k]['name'], k)
for k in fm.displayable_field_keys() if fm[k]['name']),
key=lambda x: sort_key(x[0]))
r('field_under_covers_in_grid', db.prefs, choices=choices)
self.current_font = self.initial_font = None
self.change_font_button.clicked.connect(self.change_font)
self.display_model = DisplayedFields(self.gui.current_db,
self.field_display_order)
self.display_model.dataChanged.connect(self.changed_signal)
self.field_display_order.setModel(self.display_model)
connect_lambda(
self.df_up_button.clicked, self, lambda self: move_field_up(
self.field_display_order, self.display_model))
connect_lambda(
self.df_down_button.clicked, self, lambda self: move_field_down(
self.field_display_order, self.display_model))
self.qv_display_model = QVDisplayedFields(self.gui.current_db,
self.qv_display_order)
self.qv_display_model.dataChanged.connect(self.changed_signal)
self.qv_display_order.setModel(self.qv_display_model)
connect_lambda(
self.qv_up_button.clicked, self, lambda self: move_field_up(
self.qv_display_order, self.qv_display_model))
connect_lambda(
self.qv_down_button.clicked, self, lambda self: move_field_down(
self.qv_display_order, self.qv_display_model))
self.edit_rules = EditRules(self.tabWidget)
self.edit_rules.changed.connect(self.changed_signal)
self.tabWidget.addTab(self.edit_rules,
QIcon(I('format-fill-color.png')),
_('Column &coloring'))
self.icon_rules = EditRules(self.tabWidget)
self.icon_rules.changed.connect(self.changed_signal)
self.tabWidget.addTab(self.icon_rules, QIcon(I('icon_choose.png')),
_('Column &icons'))
self.grid_rules = EditRules(self.emblems_tab)
self.grid_rules.changed.connect(self.changed_signal)
self.emblems_tab.setLayout(QVBoxLayout())
self.emblems_tab.layout().addWidget(self.grid_rules)
self.tabWidget.setCurrentIndex(0)
keys = [
QKeySequence('F11', QKeySequence.SequenceFormat.PortableText),
QKeySequence('Ctrl+Shift+F',
QKeySequence.SequenceFormat.PortableText)
]
keys = [
str(x.toString(QKeySequence.SequenceFormat.NativeText))
for x in keys
]
self.fs_help_msg.setText(
self.fs_help_msg.text() %
(QKeySequence(QKeySequence.StandardKey.FullScreen).toString(
QKeySequence.SequenceFormat.NativeText)))
self.size_calculated.connect(self.update_cg_cache_size,
type=Qt.ConnectionType.QueuedConnection)
self.tabWidget.currentChanged.connect(self.tab_changed)
l = self.cg_background_box.layout()
self.cg_bg_widget = w = Background(self)
l.addWidget(w, 0, 0, 3, 1)
self.cover_grid_color_button = b = QPushButton(_('Change &color'),
self)
b.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
l.addWidget(b, 0, 1)
b.clicked.connect(self.change_cover_grid_color)
self.cover_grid_texture_button = b = QPushButton(
_('Change &background image'), self)
b.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
l.addWidget(b, 1, 1)
b.clicked.connect(self.change_cover_grid_texture)
self.cover_grid_default_appearance_button = b = QPushButton(
_('Restore default &appearance'), self)
b.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
l.addWidget(b, 2, 1)
b.clicked.connect(self.restore_cover_grid_appearance)
self.cover_grid_empty_cache.clicked.connect(self.empty_cache)
self.cover_grid_open_cache.clicked.connect(self.open_cg_cache)
connect_lambda(self.cover_grid_smaller_cover.clicked, self,
lambda self: self.resize_cover(True))
connect_lambda(self.cover_grid_larger_cover.clicked, self,
lambda self: self.resize_cover(False))
self.cover_grid_reset_size.clicked.connect(self.cg_reset_size)
self.opt_cover_grid_disk_cache_size.setMinimum(
self.gui.grid_view.thumbnail_cache.min_disk_cache)
self.opt_cover_grid_disk_cache_size.setMaximum(
self.gui.grid_view.thumbnail_cache.min_disk_cache * 100)
self.opt_cover_grid_width.valueChanged.connect(
self.update_aspect_ratio)
self.opt_cover_grid_height.valueChanged.connect(
self.update_aspect_ratio)
self.opt_book_details_css.textChanged.connect(self.changed_signal)
from calibre.gui2.tweak_book.editor.text import get_highlighter, get_theme
self.css_highlighter = get_highlighter('css')()
self.css_highlighter.apply_theme(get_theme(None))
self.css_highlighter.set_document(self.opt_book_details_css.document())
def show_context_menu(self, point):
idx = self.table.indexAt(point)
if idx.column() != 0:
return
m = self.au_context_menu = QMenu(self)
item = self.table.itemAt(point)
disable_copy_paste_search = len(
self.table.selectedItems()) != 1 or item.is_deleted
ca = m.addAction(_('Copy'))
ca.triggered.connect(partial(self.copy_to_clipboard, item))
ca.setIcon(QIcon(I('edit-copy.png')))
if disable_copy_paste_search:
ca.setEnabled(False)
ca = m.addAction(_('Paste'))
ca.setIcon(QIcon(I('edit-paste.png')))
ca.triggered.connect(partial(self.paste_from_clipboard, item))
if disable_copy_paste_search:
ca.setEnabled(False)
ca = m.addAction(_('Undo'))
ca.setIcon(QIcon(I('edit-undo.png')))
ca.triggered.connect(self.undo_edit)
ca.setEnabled(False)
for item in self.table.selectedItems():
if (item.text() != self.original_names[int(
item.data(Qt.ItemDataRole.UserRole))] or item.is_deleted):
ca.setEnabled(True)
break
ca = m.addAction(_('Edit'))
ca.setIcon(QIcon(I('edit_input.png')))
ca.triggered.connect(self.rename_tag)
ca = m.addAction(_('Delete'))
ca.setIcon(QIcon(I('trash.png')))
ca.triggered.connect(self.delete_tags)
item_name = str(item.text())
ca = m.addAction(_('Search for {}').format(item_name))
ca.setIcon(QIcon(I('search.png')))
ca.triggered.connect(partial(self.set_search_text, item_name))
item_name = str(item.text())
ca = m.addAction(_('Filter by {}').format(item_name))
ca.setIcon(QIcon(I('filter.png')))
ca.triggered.connect(partial(self.set_filter_text, item_name))
if self.category is not None:
ca = m.addAction(_("Search the library for {0}").format(item_name))
ca.setIcon(QIcon(I('lt.png')))
ca.triggered.connect(partial(self.search_for_books, item))
if disable_copy_paste_search:
ca.setEnabled(False)
if self.table.state() == QAbstractItemView.State.EditingState:
m.addSeparator()
case_menu = QMenu(_('Change case'))
case_menu.setIcon(QIcon(I('font_size_larger.png')))
action_upper_case = case_menu.addAction(_('Upper case'))
action_lower_case = case_menu.addAction(_('Lower case'))
action_swap_case = case_menu.addAction(_('Swap case'))
action_title_case = case_menu.addAction(_('Title case'))
action_capitalize = case_menu.addAction(_('Capitalize'))
action_upper_case.triggered.connect(
partial(self.do_case, icu_upper))
action_lower_case.triggered.connect(
partial(self.do_case, icu_lower))
action_swap_case.triggered.connect(
partial(self.do_case, self.swap_case))
action_title_case.triggered.connect(
partial(self.do_case, titlecase))
action_capitalize.triggered.connect(
partial(self.do_case, capitalize))
m.addMenu(case_menu)
m.exec(self.table.mapToGlobal(point))
def data(self, index, role):
if role == Qt.ItemDataRole.DecorationRole:
w = self.widgets[index.row()]
if w.ICON:
return (QIcon(w.ICON))
return QStringListModel.data(self, index, role)
def __init__(self, parent, prefs):
QStackedWidget.__init__(self, parent)
self.prefs = prefs
self.setMinimumWidth(250)
self.root_pane = rp = QWidget(self)
self.item_pane = ip = QWidget(self)
self.current_item = None
sa = QScrollArea(self)
sa.setWidgetResizable(True)
sa.setWidget(rp)
self.addWidget(sa)
sa = QScrollArea(self)
sa.setWidgetResizable(True)
sa.setWidget(ip)
self.addWidget(sa)
self.l1 = la = QLabel('<p>'+_(
'You can edit existing entries in the Table of Contents by clicking them'
' in the panel to the left.')+'<p>'+_(
'Entries with a green tick next to them point to a location that has '
'been verified to exist. Entries with a red dot are broken and may need'
' to be fixed.'))
la.setStyleSheet('QLabel { margin-bottom: 20px }')
la.setWordWrap(True)
l = rp.l = QVBoxLayout()
rp.setLayout(l)
l.addWidget(la)
self.add_new_to_root_button = b = QPushButton(_('Create a &new entry'))
b.clicked.connect(self.add_new_to_root)
l.addWidget(b)
l.addStretch()
self.cfmhb = b = QPushButton(_('Generate ToC from &major headings'))
b.clicked.connect(self.create_from_major_headings)
b.setToolTip(textwrap.fill(_(
'Generate a Table of Contents from the major headings in the book.'
' This will work if the book identifies its headings using HTML'
' heading tags. Uses the <h1>, <h2> and <h3> tags.')))
l.addWidget(b)
self.cfmab = b = QPushButton(_('Generate ToC from &all headings'))
b.clicked.connect(self.create_from_all_headings)
b.setToolTip(textwrap.fill(_(
'Generate a Table of Contents from all the headings in the book.'
' This will work if the book identifies its headings using HTML'
' heading tags. Uses the <h1-6> tags.')))
l.addWidget(b)
self.lb = b = QPushButton(_('Generate ToC from &links'))
b.clicked.connect(self.create_from_links)
b.setToolTip(textwrap.fill(_(
'Generate a Table of Contents from all the links in the book.'
' Links that point to destinations that do not exist in the book are'
' ignored. Also multiple links with the same destination or the same'
' text are ignored.'
)))
l.addWidget(b)
self.cfb = b = QPushButton(_('Generate ToC from &files'))
b.clicked.connect(self.create_from_files)
b.setToolTip(textwrap.fill(_(
'Generate a Table of Contents from individual files in the book.'
' Each entry in the ToC will point to the start of the file, the'
' text of the entry will be the "first line" of text from the file.'
)))
l.addWidget(b)
self.xpb = b = QPushButton(_('Generate ToC from &XPath'))
b.clicked.connect(self.create_from_user_xpath)
b.setToolTip(textwrap.fill(_(
'Generate a Table of Contents from arbitrary XPath expressions.'
)))
l.addWidget(b)
self.fal = b = QPushButton(_('&Flatten the ToC'))
b.clicked.connect(self.flatten_toc)
b.setToolTip(textwrap.fill(_(
'Flatten the Table of Contents, putting all entries at the top level'
)))
l.addWidget(b)
l.addStretch()
self.w1 = la = QLabel(_('<b>WARNING:</b> calibre only supports the '
'creation of linear ToCs in AZW3 files. In a '
'linear ToC every entry must point to a '
'location after the previous entry. If you '
'create a non-linear ToC it will be '
'automatically re-arranged inside the AZW3 file.'
))
la.setWordWrap(True)
l.addWidget(la)
l = ip.l = QGridLayout()
ip.setLayout(l)
la = ip.heading = QLabel('')
l.addWidget(la, 0, 0, 1, 2)
la.setWordWrap(True)
la = ip.la = QLabel(_(
'You can move this entry around the Table of Contents by drag '
'and drop or using the up and down buttons to the left'))
la.setWordWrap(True)
l.addWidget(la, 1, 0, 1, 2)
# Item status
ip.hl1 = hl = QFrame()
hl.setFrameShape(QFrame.Shape.HLine)
l.addWidget(hl, l.rowCount(), 0, 1, 2)
self.icon_label = QLabel()
self.status_label = QLabel()
self.status_label.setWordWrap(True)
l.addWidget(self.icon_label, l.rowCount(), 0)
l.addWidget(self.status_label, l.rowCount()-1, 1)
ip.hl2 = hl = QFrame()
hl.setFrameShape(QFrame.Shape.HLine)
l.addWidget(hl, l.rowCount(), 0, 1, 2)
# Edit/remove item
rs = l.rowCount()
ip.b1 = b = QPushButton(QIcon(I('edit_input.png')),
_('Change the &location this entry points to'), self)
b.clicked.connect(self.edit_item)
l.addWidget(b, l.rowCount()+1, 0, 1, 2)
ip.b2 = b = QPushButton(QIcon(I('trash.png')),
_('&Remove this entry'), self)
l.addWidget(b, l.rowCount(), 0, 1, 2)
b.clicked.connect(self.delete_item)
ip.hl3 = hl = QFrame()
hl.setFrameShape(QFrame.Shape.HLine)
l.addWidget(hl, l.rowCount(), 0, 1, 2)
l.setRowMinimumHeight(rs, 20)
# Add new item
rs = l.rowCount()
ip.b3 = b = QPushButton(QIcon(I('plus.png')), _('New entry &inside this entry'))
connect_lambda(b.clicked, self, lambda self: self.add_new('inside'))
l.addWidget(b, l.rowCount()+1, 0, 1, 2)
ip.b4 = b = QPushButton(QIcon(I('plus.png')), _('New entry &above this entry'))
connect_lambda(b.clicked, self, lambda self: self.add_new('before'))
l.addWidget(b, l.rowCount(), 0, 1, 2)
ip.b5 = b = QPushButton(QIcon(I('plus.png')), _('New entry &below this entry'))
connect_lambda(b.clicked, self, lambda self: self.add_new('after'))
l.addWidget(b, l.rowCount(), 0, 1, 2)
# Flatten entry
ip.b3 = b = QPushButton(QIcon(I('heuristics.png')), _('&Flatten this entry'))
b.clicked.connect(self.flatten_item)
b.setToolTip(_('All children of this entry are brought to the same '
'level as this entry.'))
l.addWidget(b, l.rowCount()+1, 0, 1, 2)
ip.hl4 = hl = QFrame()
hl.setFrameShape(QFrame.Shape.HLine)
l.addWidget(hl, l.rowCount(), 0, 1, 2)
l.setRowMinimumHeight(rs, 20)
# Return to welcome
rs = l.rowCount()
ip.b4 = b = QPushButton(QIcon(I('back.png')), _('&Return to welcome screen'))
b.clicked.connect(self.go_to_root)
b.setToolTip(_('Go back to the top level view'))
l.addWidget(b, l.rowCount()+1, 0, 1, 2)
l.setRowMinimumHeight(rs, 20)
l.addWidget(QLabel(), l.rowCount(), 0, 1, 2)
l.setColumnStretch(1, 10)
l.setRowStretch(l.rowCount()-1, 10)
self.w2 = la = QLabel(self.w1.text())
self.w2.setWordWrap(True)
l.addWidget(la, l.rowCount(), 0, 1, 2)
def setup_ui(self):
self.setWindowIcon(QIcon(I('diff.png')))
self.stacks = st = QStackedLayout(self)
self.busy = BusyWidget(self)
self.w = QWidget(self)
st.addWidget(self.busy), st.addWidget(self.w)
self.setLayout(st)
self.l = l = QGridLayout()
self.w.setLayout(l)
self.view = v = DiffView(self,
show_open_in_editor=self.show_open_in_editor)
l.addWidget(v, l.rowCount(), 0, 1, -1)
r = l.rowCount()
self.bp = b = QToolButton(self)
b.setIcon(QIcon(I('back.png')))
connect_lambda(b.clicked, self, lambda self: self.view.next_change(-1))
b.setToolTip(_('Go to previous change') + ' [p]')
b.setText(_('&Previous change')), b.setToolButtonStyle(
Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
l.addWidget(b, r, 0)
self.bn = b = QToolButton(self)
b.setIcon(QIcon(I('forward.png')))
connect_lambda(b.clicked, self, lambda self: self.view.next_change(1))
b.setToolTip(_('Go to next change') + ' [n]')
b.setText(_('&Next change')), b.setToolButtonStyle(
Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
l.addWidget(b, r, 1)
self.search = s = HistoryLineEdit2(self)
s.initialize('diff_search_history')
l.addWidget(s, r, 2)
s.setPlaceholderText(_('Search for text'))
connect_lambda(s.returnPressed, self,
lambda self: self.do_search(False))
self.sbn = b = QToolButton(self)
b.setIcon(QIcon(I('arrow-down.png')))
connect_lambda(b.clicked, self, lambda self: self.do_search(False))
b.setToolTip(_('Find next match'))
b.setText(_('Next &match')), b.setToolButtonStyle(
Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
l.addWidget(b, r, 3)
self.sbp = b = QToolButton(self)
b.setIcon(QIcon(I('arrow-up.png')))
connect_lambda(b.clicked, self, lambda self: self.do_search(True))
b.setToolTip(_('Find previous match'))
b.setText(_('P&revious match')), b.setToolButtonStyle(
Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
l.addWidget(b, r, 4)
self.lb = b = QRadioButton(_('Left panel'), self)
b.setToolTip(_('Perform search in the left panel'))
l.addWidget(b, r, 5)
self.rb = b = QRadioButton(_('Right panel'), self)
b.setToolTip(_('Perform search in the right panel'))
l.addWidget(b, r, 6)
b.setChecked(True)
self.pb = b = QToolButton(self)
b.setIcon(QIcon(I('config.png')))
b.setText(_('&Options')), b.setToolButtonStyle(
Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
b.setToolTip(_('Change how the differences are displayed'))
b.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
m = QMenu(b)
b.setMenu(m)
cm = self.cm = QMenu(_('Lines of context around each change'))
for i in (3, 5, 10, 50):
cm.addAction(
_('Show %d lines of context') % i,
partial(self.change_context, i))
cm.addAction(_('Show all text'), partial(self.change_context, None))
self.beautify_action = m.addAction('', self.toggle_beautify)
self.set_beautify_action_text()
m.addMenu(cm)
l.addWidget(b, r, 7)
self.hl = QHBoxLayout()
l.addLayout(self.hl, l.rowCount(), 0, 1, -1)
self.names = QLabel('')
self.hl.addWidget(self.names, stretch=100)
if self.show_open_in_editor:
self.edit_msg = QLabel(_('Double click right side to edit'))
self.edit_msg.setToolTip(
textwrap.fill(
_('Double click on any change in the right panel to edit that location in the editor'
)))
self.hl.addWidget(self.edit_msg)
self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Close)
if self.revert_button_msg is not None:
self.rvb = b = self.bb.addButton(
self.revert_button_msg, QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon(I('edit-undo.png'))), b.setAutoDefault(False)
b.clicked.connect(self.revert_requested)
b.clicked.connect(self.reject)
self.bb.button(QDialogButtonBox.StandardButton.Close).setDefault(True)
self.hl.addWidget(self.bb)
self.view.setFocus(Qt.FocusReason.OtherFocusReason)
def setup_ui(self): # {{{
self.setWindowModality(Qt.WindowModality.ApplicationModal)
self.setWindowIcon(QIcon(I('column.png')))
self.vl = l = QVBoxLayout(self)
self.heading_label = la = QLabel('')
l.addWidget(la)
self.shortcuts = s = QLabel('')
s.setWordWrap(True)
s.linkActivated.connect(self.shortcut_activated)
text = '<p>' + _('Quick create:')
for col, name in [('isbn', _('ISBN')), ('formats', _('Formats')),
('yesno', _('Yes/No')), ('tags', _('Tags')),
('series', ngettext('Series', 'Series', 1)),
('rating', _('Rating')), ('people', _("Names")),
('text', _('Short text'))]:
text += ' <a href="col:%s">%s</a>,' % (col, name)
text = text[:-1]
s.setText(text)
l.addWidget(s)
self.g = g = QGridLayout()
l.addLayout(g)
l.addStretch(10)
self.button_box = bb = QDialogButtonBox(
QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel, self)
bb.accepted.connect(self.accept), bb.rejected.connect(self.reject)
l.addWidget(bb)
def add_row(text, widget):
if text is None:
f = g.addWidget if isinstance(widget, QWidget) else g.addLayout
f(widget, g.rowCount(), 0, 1, -1)
return
row = g.rowCount()
la = QLabel(text)
g.addWidget(la, row, 0, 1, 1)
if isinstance(widget, QWidget):
la.setBuddy(widget)
g.addWidget(widget, row, 1, 1, 1)
else:
widget.setContentsMargins(0, 0, 0, 0)
g.addLayout(widget, row, 1, 1, 1)
for i in range(widget.count()):
w = widget.itemAt(i).widget()
if isinstance(w, QWidget):
la.setBuddy(w)
break
return la
# Lookup name
self.column_name_box = cnb = QLineEdit(self)
cnb.setToolTip(
_("Used for searching the column. Must contain only digits and lower case letters."
))
add_row(_("&Lookup name:"), cnb)
# Heading
self.column_heading_box = chb = QLineEdit(self)
chb.setToolTip(
_("Column heading in the library view and category name in the Tag browser"
))
add_row(_("Column &heading:"), chb)
# Column Type
h = QHBoxLayout()
self.column_type_box = ctb = QComboBox(self)
ctb.setMinimumWidth(70)
ctb.setToolTip(
_("What kind of information will be kept in the column."))
h.addWidget(ctb)
self.use_decorations = ud = QCheckBox(_("Show &checkmarks"), self)
ud.setToolTip(
_("Show check marks in the GUI. Values of 'yes', 'checked', and 'true'\n"
"will show a green check. Values of 'no', 'unchecked', and 'false' will show a red X.\n"
"Everything else will show nothing."))
h.addWidget(ud)
self.is_names = ins = QCheckBox(_("Contains names"), self)
ins.setToolTip(
_("Check this box if this column contains names, like the authors column."
))
h.addWidget(ins)
add_row(_("&Column type:"), h)
# Description
self.description_box = d = QLineEdit(self)
d.setToolTip(_("Optional text describing what this column is for"))
add_row(_("D&escription:"), d)
# Date/number formatting
h = QHBoxLayout()
self.format_box = fb = QLineEdit(self)
h.addWidget(fb)
self.format_default_label = la = QLabel('')
la.setOpenExternalLinks(True), la.setWordWrap(True)
h.addWidget(la)
self.format_label = add_row('', h)
# Template
self.composite_box = cb = TemplateLineEditor(self)
self.composite_default_label = cdl = QLabel(_("Default: (nothing)"))
cb.setToolTip(
_("Field template. Uses the same syntax as save templates."))
cdl.setToolTip(
_("Similar to save templates. For example, %s") % "{title} {isbn}")
h = QHBoxLayout()
h.addWidget(cb), h.addWidget(cdl)
self.composite_label = add_row(_("&Template:"), h)
# Comments properties
self.comments_heading_position = ct = QComboBox(self)
for k, text in (('hide', _('No heading')),
('above', _('Show heading above the text')),
('side', _('Show heading to the side of the text'))):
ct.addItem(text, k)
ct.setToolTip(
_('Choose whether or not the column heading is shown in the Book\n'
'details panel and, if shown, where'))
self.comments_heading_position_label = add_row(_('Column heading:'),
ct)
self.comments_type = ct = QComboBox(self)
for k, text in (('html', 'HTML'), ('short-text',
_('Short text, like a title')),
('long-text', _('Plain text')),
('markdown',
_('Plain text formatted using markdown'))):
ct.addItem(text, k)
ct.setToolTip(
_('Choose how the data in this column is interpreted.\n'
'This controls how the data is displayed in the Book details panel\n'
'and how it is edited.'))
self.comments_type_label = add_row(
_('Interpret this column as:') + ' ', ct)
# Values for enum type
self.enum_box = eb = QLineEdit(self)
eb.setToolTip(
_("A comma-separated list of permitted values. The empty value is always\n"
"included, and is the default. For example, the list 'one,two,three' has\n"
"four values, the first of them being the empty value."))
self.enum_default_label = add_row(_("&Values:"), eb)
self.enum_colors = ec = QLineEdit(self)
ec.setToolTip(
_("A list of color names to use when displaying an item. The\n"
"list must be empty or contain a color for each value."))
self.enum_colors_label = add_row(_('Colors:'), ec)
# Rating allow half stars
self.allow_half_stars = ahs = QCheckBox(_('Allow half stars'))
ahs.setToolTip(_('Allow half star ratings, for example: ') + '★★★⯨')
add_row(None, ahs)
# Composite display properties
l = QHBoxLayout()
self.composite_sort_by_label = la = QLabel(_("&Sort/search column by"))
self.composite_sort_by = csb = QComboBox(self)
la.setBuddy(csb), csb.setToolTip(
_("How this column should handled in the GUI when sorting and searching"
))
l.addWidget(la), l.addWidget(csb)
self.composite_make_category = cmc = QCheckBox(
_("Show in Tag browser"))
cmc.setToolTip(
_("If checked, this column will appear in the Tag browser as a category"
))
l.addWidget(cmc)
self.composite_contains_html = cch = QCheckBox(
_("Show as HTML in Book details"))
cch.setToolTip(
'<p>' +
_('If checked, this column will be displayed as HTML in '
'Book details and the Content server. This can be used to '
'construct links with the template language. For example, '
'the template '
'<pre><big><b>{title}</b></big>'
'{series:| [|}{series_index:| [|]]}</pre>'
'will create a field displaying the title in bold large '
'characters, along with the series, for example <br>"<big><b>'
'An Oblique Approach</b></big> [Belisarius [1]]". The template '
'<pre><a href="https://www.beam-ebooks.de/ebook/{identifiers'
':select(beam)}">Beam book</a></pre> '
'will generate a link to the book on the Beam e-books site.') +
'</p>')
l.addWidget(cch)
add_row(None, l)
# Default value
self.default_value = dv = QLineEdit(self)
dv.setToolTip('<p>' + _(
'Default value when a new book is added to the '
'library. For Date columns enter the word "Now", or the date as '
'yyyy-mm-dd. For Yes/No columns enter "Yes" or "No". For Text with '
'a fixed set of values enter one of the permitted values. For '
'Rating columns enter a number between 0 and 5.') + '</p>')
self.default_value_label = add_row(_('Default value:'), dv)
self.resize(self.sizeHint())
def button(icon, text, tt, target):
b = QPushButton(QIcon(I(icon)), text, self)
b.setToolTip(tt)
b.setFocusPolicy(Qt.FocusPolicy.NoFocus)
b.clicked.connect(target)
return b
def __init__(self, recipe_model, parent=None):
QDialog.__init__(self, parent)
self.commit_on_change = True
self.previous_urn = None
self.setWindowIcon(QIcon(I('scheduler.png')))
self.l = l = QGridLayout(self)
# Left panel
self.h = h = QHBoxLayout()
l.addLayout(h, 0, 0, 1, 1)
self.search = s = SearchBox2(self)
self.search.initialize('scheduler_search_history')
self.search.setMinimumContentsLength(15)
self.go_button = b = QToolButton(self)
b.setText(_("Go"))
b.clicked.connect(self.search.do_search)
h.addWidget(s), h.addWidget(b)
self.recipes = RecipesView(self)
l.addWidget(self.recipes, 1, 0, 2, 1)
self.recipe_model = recipe_model
self.recipe_model.do_refresh()
self.recipes.setModel(self.recipe_model)
self.recipes.setFocus(Qt.FocusReason.OtherFocusReason)
self.recipes.item_activated.connect(self.download_clicked)
self.setWindowTitle(
_("Schedule news download [{} sources]").format(
self.recipe_model.showing_count))
self.search.search.connect(self.recipe_model.search)
self.recipe_model.searched.connect(
self.search.search_done, type=Qt.ConnectionType.QueuedConnection)
self.recipe_model.searched.connect(self.search_done)
# Right Panel
self.scroll_area_contents = sac = QWidget(self)
self.l.addWidget(sac, 0, 1, 2, 1)
sac.v = v = QVBoxLayout(sac)
v.setContentsMargins(0, 0, 0, 0)
self.detail_box = QTabWidget(self)
self.detail_box.setVisible(False)
self.detail_box.setCurrentIndex(0)
v.addWidget(self.detail_box)
v.addItem(
QSpacerItem(20, 40, QSizePolicy.Policy.Minimum,
QSizePolicy.Policy.Expanding))
# First Tab (scheduling)
self.tab = QWidget()
self.detail_box.addTab(self.tab, _("&Schedule"))
self.tab.v = vt = QVBoxLayout(self.tab)
vt.setContentsMargins(0, 0, 0, 0)
self.blurb = la = QLabel('blurb')
la.setWordWrap(True), la.setOpenExternalLinks(True)
vt.addWidget(la)
self.frame = f = QFrame(self.tab)
vt.addWidget(f)
f.setFrameShape(QFrame.Shape.StyledPanel)
f.setFrameShadow(QFrame.Shadow.Raised)
f.v = vf = QVBoxLayout(f)
self.schedule = s = QCheckBox(_("&Schedule for download:"), f)
self.schedule.stateChanged[int].connect(self.toggle_schedule_info)
vf.addWidget(s)
f.h = h = QHBoxLayout()
vf.addLayout(h)
self.days_of_week = QRadioButton(_("&Days of week"), f)
self.days_of_month = QRadioButton(_("Da&ys of month"), f)
self.every_x_days = QRadioButton(_("Every &x days"), f)
self.days_of_week.setChecked(True)
h.addWidget(self.days_of_week), h.addWidget(
self.days_of_month), h.addWidget(self.every_x_days)
self.schedule_stack = ss = QStackedWidget(f)
self.schedule_widgets = []
for key in reversed(self.SCHEDULE_TYPES):
self.schedule_widgets.insert(0, self.SCHEDULE_TYPES[key](self))
self.schedule_stack.insertWidget(0, self.schedule_widgets[0])
vf.addWidget(ss)
self.last_downloaded = la = QLabel(f)
la.setWordWrap(True)
vf.addWidget(la)
self.account = acc = QGroupBox(self.tab)
acc.setTitle(_("&Account"))
vt.addWidget(acc)
acc.g = g = QGridLayout(acc)
acc.unla = la = QLabel(_("&Username:"******"&Password:"******"&Show password"), self.account)
spw.stateChanged[int].connect(self.set_pw_echo_mode)
g.addWidget(spw, 2, 0, 1, 2)
self.rla = la = QLabel(
_("For the scheduling to work, you must leave calibre running."))
vt.addWidget(la)
for b, c in iteritems(self.SCHEDULE_TYPES):
b = getattr(self, b)
b.toggled.connect(self.schedule_type_selected)
b.setToolTip(textwrap.dedent(c.HELP))
# Second tab (advanced settings)
self.tab2 = t2 = QWidget()
self.detail_box.addTab(self.tab2, _("&Advanced"))
self.tab2.g = g = QGridLayout(t2)
g.setContentsMargins(0, 0, 0, 0)
self.add_title_tag = tt = QCheckBox(_("Add &title as tag"), t2)
g.addWidget(tt, 0, 0, 1, 2)
t2.la = la = QLabel(_("&Extra tags:"))
self.custom_tags = ct = QLineEdit(self)
la.setBuddy(ct)
g.addWidget(la), g.addWidget(ct, 1, 1)
t2.la2 = la = QLabel(_("&Keep at most:"))
la.setToolTip(
_("Maximum number of copies (issues) of this recipe to keep. Set to 0 to keep all (disable)."
))
self.keep_issues = ki = QSpinBox(t2)
tt.toggled['bool'].connect(self.keep_issues.setEnabled)
ki.setMaximum(100000), la.setBuddy(ki)
ki.setToolTip(
_("<p>When set, this option will cause calibre to keep, at most, the specified number of issues"
" of this periodical. Every time a new issue is downloaded, the oldest one is deleted, if the"
" total is larger than this number.\n<p>Note that this feature only works if you have the"
" option to add the title as tag checked, above.\n<p>Also, the setting for deleting periodicals"
" older than a number of days, below, takes priority over this setting."
))
ki.setSpecialValueText(_("all issues")), ki.setSuffix(_(" issues"))
g.addWidget(la), g.addWidget(ki, 2, 1)
si = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum,
QSizePolicy.Policy.Expanding)
g.addItem(si, 3, 1, 1, 1)
# Bottom area
self.hb = h = QHBoxLayout()
self.l.addLayout(h, 2, 1, 1, 1)
self.labt = la = QLabel(_("Delete downloaded &news older than:"))
self.old_news = on = QSpinBox(self)
on.setToolTip(
_("<p>Delete downloaded news older than the specified number of days. Set to zero to disable.\n"
"<p>You can also control the maximum number of issues of a specific periodical that are kept"
" by clicking the Advanced tab for that periodical above."))
on.setSpecialValueText(_("never delete")), on.setSuffix(_(" days"))
on.setMaximum(1000), la.setBuddy(on)
on.setValue(gconf['oldest_news'])
h.addWidget(la), h.addWidget(on)
self.download_all_button = b = QPushButton(
QIcon(I('news.png')), _("Download &all scheduled"), self)
b.setToolTip(_("Download all scheduled news sources at once"))
b.clicked.connect(self.download_all_clicked)
self.l.addWidget(b, 3, 0, 1, 1)
self.bb = bb = QDialogButtonBox(
QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel, self)
bb.accepted.connect(self.accept), bb.rejected.connect(self.reject)
self.download_button = b = bb.addButton(
_('&Download now'), QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon(I('arrow-down.png'))), b.setVisible(False)
b.clicked.connect(self.download_clicked)
self.l.addWidget(bb, 3, 1, 1, 1)
geom = gprefs.get('scheduler_dialog_geometry')
if geom is not None:
QApplication.instance().safe_restore_geometry(self, geom)
Qt.ConnectionType.QueuedConnection)
def stop_animation(self):
self.animation.stop()
self.animation_finished()
def paintEvent(self, ev):
size = self._icon_size if self._icon_size > 10 else self.iconSize(
).width()
p = QPainter(self)
opt = QStyleOptionToolButton()
self.initStyleOption(opt)
s = self.style()
opt.iconSize = QSize(size, size)
s.drawComplexControl(QStyle.ComplexControl.CC_ToolButton, opt, p, self)
if __name__ == '__main__':
from qt.core import QApplication, QHBoxLayout
app = QApplication([])
w = QWidget()
w.setLayout(QHBoxLayout())
b = ThrobbingButton()
b.setIcon(QIcon(I('donate.png')))
w.layout().addWidget(b)
w.show()
b.set_normal_icon_size(64, 64)
b.start_animation()
app.exec_()
def __init__(self, parent):
QFrame.__init__(self, parent)
self.setFrameStyle(QFrame.Shape.NoFrame if gprefs['tag_browser_old_look'] else QFrame.Shape.StyledPanel)
self._parent = parent
self._layout = QVBoxLayout(self)
self._layout.setContentsMargins(0,0,0,0)
# Set up the find box & button
self.tb_bar = tbb = TagBrowserBar(self)
tbb.clear_find.connect(self.reset_find)
self.alter_tb, self.item_search, self.search_button = tbb.alter_tb, tbb.item_search, tbb.search_button
self.toggle_search_button = tbb.toggle_search_button
self._layout.addWidget(tbb)
self.current_find_position = None
self.search_button.clicked.connect(self.find)
self.item_search.lineEdit().textEdited.connect(self.find_text_changed)
self.item_search.activated[str].connect(self.do_find)
# The tags view
parent.tags_view = TagsView(parent)
self.tags_view = parent.tags_view
self._layout.insertWidget(0, parent.tags_view)
# Now the floating 'not found' box
l = QLabel(self.tags_view)
self.not_found_label = l
l.setFrameStyle(QFrame.Shape.StyledPanel)
l.setAutoFillBackground(True)
l.setText('<p><b>'+_('No more matches.</b><p> Click Find again to go to first match'))
l.setAlignment(Qt.AlignmentFlag.AlignVCenter)
l.setWordWrap(True)
l.resize(l.sizeHint())
l.move(10,20)
l.setVisible(False)
self.not_found_label_timer = QTimer()
self.not_found_label_timer.setSingleShot(True)
self.not_found_label_timer.timeout.connect(self.not_found_label_timer_event,
type=Qt.ConnectionType.QueuedConnection)
self.collapse_all_action = ac = QAction(parent)
parent.addAction(ac)
parent.keyboard.register_shortcut('tag browser collapse all',
_('Collapse all'), default_keys=(),
action=ac, group=_('Tag browser'))
connect_lambda(ac.triggered, self, lambda self: self.tags_view.collapseAll())
# The Configure Tag Browser button
l = self.alter_tb
ac = QAction(parent)
parent.addAction(ac)
parent.keyboard.register_shortcut('tag browser alter',
_('Configure Tag browser'), default_keys=(),
action=ac, group=_('Tag browser'))
ac.triggered.connect(l.showMenu)
l.m.aboutToShow.connect(self.about_to_show_configure_menu)
l.m.show_counts_action = ac = l.m.addAction('counts')
ac.triggered.connect(self.toggle_counts)
l.m.show_avg_rating_action = ac = l.m.addAction(QIcon.ic('rating.png'), 'avg rating')
ac.triggered.connect(self.toggle_avg_rating)
sb = l.m.addAction(QIcon.ic('sort.png'), _('Sort by'))
sb.m = l.sort_menu = QMenu(l.m)
sb.setMenu(sb.m)
sb.bg = QActionGroup(sb)
# Must be in the same order as db2.CATEGORY_SORTS
for i, x in enumerate((_('Name'), _('Number of books'),
_('Average rating'))):
a = sb.m.addAction(x)
sb.bg.addAction(a)
a.setCheckable(True)
if i == 0:
a.setChecked(True)
sb.setToolTip(
_('Set the sort order for entries in the Tag browser'))
sb.setStatusTip(sb.toolTip())
ma = l.m.addAction(QIcon.ic('search.png'), _('Search type when selecting multiple items'))
ma.m = l.match_menu = QMenu(l.m)
ma.setMenu(ma.m)
ma.ag = QActionGroup(ma)
# Must be in the same order as db2.MATCH_TYPE
for i, x in enumerate((_('Match any of the items'), _('Match all of the items'))):
a = ma.m.addAction(x)
ma.ag.addAction(a)
a.setCheckable(True)
if i == 0:
a.setChecked(True)
ma.setToolTip(
_('When selecting multiple entries in the Tag browser '
'match any or all of them'))
ma.setStatusTip(ma.toolTip())
mt = l.m.addAction(_('Manage authors, tags, etc.'))
mt.setToolTip(_('All of these category_managers are available by right-clicking '
'on items in the Tag browser above'))
mt.m = l.manage_menu = QMenu(l.m)
mt.setMenu(mt.m)
ac = QAction(parent)
parent.addAction(ac)
parent.keyboard.register_shortcut('tag browser toggle item',
_("'Click' found item"), default_keys=(),
action=ac, group=_('Tag browser'))
ac.triggered.connect(self.toggle_item)
ac = QAction(parent)
parent.addAction(ac)
parent.keyboard.register_shortcut('tag browser set focus',
_("Give the Tag browser keyboard focus"), default_keys=(),
action=ac, group=_('Tag browser'))
ac.triggered.connect(self.give_tb_focus)
def __init__(self, parent):
QWidget.__init__(self, parent)
self.setVisible(False)
parent.installEventFilter(self)
self._show_fraction = 0.0
self.show_animation = a = QPropertyAnimation(self, b"show_fraction",
self)
a.setDuration(1000), a.setEasingCurve(QEasingCurve.Type.OutQuad)
a.setStartValue(0.0), a.setEndValue(1.0)
a.finished.connect(self.stop_show_animation)
self.rendered_pixmap = None
self.questions = []
self.icon = ic = Icon(self)
self.msg_label = msg = QLabel('some random filler text')
msg.setWordWrap(True)
self.bb = QDialogButtonBox()
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.log_button = self.bb.addButton(
_('View log'), QDialogButtonBox.ButtonRole.ActionRole)
self.log_button.setIcon(QIcon(I('debug.png')))
self.log_button.clicked.connect(self.show_log)
self.copy_button = self.bb.addButton(
_('&Copy to clipboard'), QDialogButtonBox.ButtonRole.ActionRole)
self.copy_button.clicked.connect(self.copy_to_clipboard)
self.action_button = self.bb.addButton(
'', QDialogButtonBox.ButtonRole.ActionRole)
self.action_button.clicked.connect(self.action_clicked)
self.show_det_msg = _('Show &details')
self.hide_det_msg = _('Hide &details')
self.det_msg_toggle = self.bb.addButton(
self.show_det_msg, QDialogButtonBox.ButtonRole.ActionRole)
self.det_msg_toggle.clicked.connect(self.toggle_det_msg)
self.det_msg_toggle.setToolTip(
_('Show detailed information about this error'))
self.det_msg = PlainTextEdit(self)
self.det_msg.setReadOnly(True)
self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Yes
| QDialogButtonBox.StandardButton.No
| QDialogButtonBox.StandardButton.Ok)
self.bb.button(QDialogButtonBox.StandardButton.Yes).setDefault(True)
self.title_label = title = QLabel('A dummy title')
f = title.font()
f.setBold(True)
title.setFont(f)
self.checkbox = QCheckBox('', self)
self._l = l = QVBoxLayout(self)
self._h = h = QHBoxLayout()
self._v = v = QVBoxLayout()
v.addWidget(title), v.addWidget(msg)
h.addWidget(ic), h.addSpacing(10), h.addLayout(v), l.addLayout(h)
l.addSpacing(5)
l.addWidget(self.checkbox)
l.addWidget(self.det_msg)
l.addWidget(self.bb)
self.ask_question.connect(self.do_ask_question,
type=Qt.ConnectionType.QueuedConnection)
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
for child in self.findChildren(QWidget):
child.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.setFocusProxy(self.parent())
self.resize_timer = t = QTimer(self)
t.setSingleShot(True), t.setInterval(100), t.timeout.connect(
self.parent_resized)
