def key_press_event(self, ev, which=0):
code = ev.key()
if self.capture == 0 or code in (0, Qt.Key.Key_unknown,
Qt.Key.Key_Shift, Qt.Key.Key_Control,
Qt.Key.Key_Alt, Qt.Key.Key_Meta,
Qt.Key.Key_AltGr, Qt.Key.Key_CapsLock,
Qt.Key.Key_NumLock,
Qt.Key.Key_ScrollLock):
return QWidget.keyPressEvent(self, ev)
sequence = QKeySequence(code
| (int(ev.modifiers())
& (~Qt.KeyboardModifier.KeypadModifier)))
setattr(self, 'shortcut%d' % which, sequence)
self.clear_button(which)
self.capture = 0
dup_desc = self.dup_check(sequence, self.key)
if dup_desc is not None:
error_dialog(self,
_('Already assigned'),
unicode_type(
sequence.toString(
QKeySequence.SequenceFormat.NativeText)) +
' ' + _('already assigned to') + ' ' + dup_desc,
show=True)
self.clear_clicked(which=which)
def __init__(self, img_data, parent=None):
QDialog.__init__(self, parent)
self.l = l = QVBoxLayout(self)
self.setWindowTitle(_('Trim Image'))
self.bar = b = QToolBar(self)
l.addWidget(b)
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
b.setIconSize(QSize(32, 32))
self.msg = la = QLabel('\xa0' + _(
'Select a region by dragging with your mouse, and then click trim')
)
self.msg_txt = self.msg.text()
self.sz = QLabel('')
self.canvas = c = Canvas(self)
c.image_changed.connect(self.image_changed)
c.load_image(img_data)
self.undo_action = u = c.undo_action
u.setShortcut(QKeySequence(QKeySequence.StandardKey.Undo))
self.redo_action = r = c.redo_action
r.setShortcut(QKeySequence(QKeySequence.StandardKey.Redo))
self.trim_action = ac = self.bar.addAction(QIcon(I('trim.png')),
_('&Trim'), self.do_trim)
ac.setShortcut(QKeySequence('Ctrl+T'))
ac.setToolTip('{} [{}]'.format(
_('Trim image by removing borders outside the selected region'),
ac.shortcut().toString(QKeySequence.SequenceFormat.NativeText)))
ac.setEnabled(False)
c.selection_state_changed.connect(self.selection_changed)
c.selection_area_changed.connect(self.selection_area_changed)
l.addWidget(c)
self.bar.addAction(self.trim_action)
self.bar.addSeparator()
self.bar.addAction(u)
self.bar.addAction(r)
self.bar.addSeparator()
self.bar.addWidget(la)
self.bar.addSeparator()
self.bar.addWidget(self.sz)
self.bb = bb = QDialogButtonBox(
QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
h = QHBoxLayout()
l.addLayout(h)
self.tr_sz = QLabel('')
h.addWidget(self.tr_sz)
h.addStretch(10)
h.addWidget(bb)
self.resize(QSize(900, 600))
geom = gprefs.get('image-trim-dialog-geometry', None)
if geom is not None:
QApplication.instance().safe_restore_geometry(self, geom)
self.setWindowIcon(self.trim_action.icon())
self.image_data = None
def __init__(self, parent, cover_flow):
QDialog.__init__(self, parent)
self._layout = QStackedLayout()
self.setLayout(self._layout)
self.setWindowTitle(_('Browse by covers'))
self.layout().addWidget(cover_flow)
geom = gprefs.get('cover_browser_dialog_geometry', None)
if not geom or not QApplication.instance().safe_restore_geometry(self, geom):
h, w = available_height()-60, int(available_width()/1.5)
self.resize(w, h)
self.action_fs_toggle = a = QAction(self)
self.addAction(a)
a.setShortcuts([QKeySequence('F11', QKeySequence.SequenceFormat.PortableText),
QKeySequence('Ctrl+Shift+F', QKeySequence.SequenceFormat.PortableText)])
a.triggered.connect(self.toggle_fullscreen)
self.action_esc_fs = a = QAction(self)
a.triggered.connect(self.show_normal)
self.addAction(a)
a.setShortcuts([QKeySequence('Esc', QKeySequence.SequenceFormat.PortableText)])
self.pre_fs_geom = None
cover_flow.setFocus(Qt.FocusReason.OtherFocusReason)
self.view_action = a = QAction(self)
iactions = parent.iactions
self.addAction(a)
a.setShortcuts(list(iactions['View'].menuless_qaction.shortcuts())+
[QKeySequence(Qt.Key.Key_Space)])
a.triggered.connect(iactions['View'].menuless_qaction.trigger)
self.sd_action = a = QAction(self)
self.addAction(a)
a.setShortcuts(list(iactions['Send To Device'].
menuless_qaction.shortcuts()))
a.triggered.connect(iactions['Send To Device'].menuless_qaction.trigger)
def create_context_menu(self):
m = QMenu(self)
m.addAction(_('Set date to undefined') + '\t' + QKeySequence(Qt.Key.Key_Minus).toString(QKeySequence.SequenceFormat.NativeText),
self.clear_date)
m.addAction(_('Set date to today') + '\t' + QKeySequence(Qt.Key.Key_Equal).toString(QKeySequence.SequenceFormat.NativeText),
self.today_date)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m, use_self_for_copy_actions=True)
return m
def get_match(self, event_or_sequence, ignore=tuple()):
q = event_or_sequence
if isinstance(q, QKeyEvent):
q = QKeySequence(q.key()|(int(q.modifiers()) & (~Qt.KeyboardModifier.KeypadModifier)))
for key in self.order:
if key not in ignore:
for seq in self.get_sequences(key):
if seq.matches(q) == QKeySequence.SequenceMatch.ExactMatch:
return key
return None
def keysequence_from_event(ev): # {{{
k, mods = ev.key(), int(ev.modifiers())
if k in (0, Qt.Key.Key_unknown, Qt.Key.Key_Shift, Qt.Key.Key_Control,
Qt.Key.Key_Alt, Qt.Key.Key_Meta, Qt.Key.Key_AltGr,
Qt.Key.Key_CapsLock, Qt.Key.Key_NumLock, Qt.Key.Key_ScrollLock):
return
letter = QKeySequence(k).toString(QKeySequence.SequenceFormat.PortableText)
if mods & Qt.Modifier.SHIFT and letter.lower() == letter.upper():
# Something like Shift+* or Shift+> we have to remove the shift,
# since it is included in keycode.
mods = mods & ~Qt.Modifier.SHIFT
return QKeySequence(k | mods)
def custom_keys(self):
if self.use_default.isChecked():
return None
ans = []
for which in (1, 2):
button = getattr(self, 'button%d' % which)
t = unicode_type(button.text())
if t == _('None'):
continue
ks = QKeySequence(t, QKeySequence.SequenceFormat.NativeText)
if not ks.isEmpty():
ans.append(ks)
return tuple(ans)
def __init__(self, logger, opts, parent=None):
MainWindow.__init__(self, opts, parent)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
self.setWindowTitle(__appname__ + _(' - LRF viewer'))
self.logger = logger
self.opts = opts
self.create_document()
self.spin_box_action = self.spin_box = QSpinBox()
self.tool_bar.addWidget(self.spin_box)
self.tool_bar.addSeparator()
self.slider_action = self.slider = QSlider(Qt.Orientation.Horizontal)
self.tool_bar.addWidget(self.slider)
self.tool_bar.addSeparator()
self.search = SearchBox2(self)
self.search.initialize('lrf_viewer_search_history')
self.search_action = self.tool_bar.addWidget(self.search)
self.search.search.connect(self.find)
self.action_next_page.setShortcuts([
QKeySequence.StandardKey.MoveToNextPage,
QKeySequence(Qt.Key.Key_Space)
])
self.action_previous_page.setShortcuts([
QKeySequence.StandardKey.MoveToPreviousPage,
QKeySequence(Qt.Key.Key_Backspace)
])
self.action_next_match.setShortcuts(QKeySequence.StandardKey.FindNext)
self.addAction(self.action_next_match)
self.action_next_page.triggered[(bool)].connect(self.next)
self.action_previous_page.triggered[(bool)].connect(self.previous)
self.action_back.triggered[(bool)].connect(self.back)
self.action_forward.triggered[(bool)].connect(self.forward)
self.action_next_match.triggered[(bool)].connect(self.next_match)
self.action_open_ebook.triggered[(bool)].connect(self.open_ebook)
self.action_configure.triggered[(bool)].connect(self.configure)
self.spin_box.valueChanged[(int)].connect(self.go_to_page)
self.slider.valueChanged[(int)].connect(self.go_to_page)
self.graphics_view.setRenderHint(QPainter.RenderHint.Antialiasing,
True)
self.graphics_view.setRenderHint(QPainter.RenderHint.TextAntialiasing,
True)
self.graphics_view.setRenderHint(
QPainter.RenderHint.SmoothPixmapTransform, True)
self.closed = False
def init_search_box_mixin(self):
self.search.initialize('main_search_history', colorize=True,
help_text=_('Search (For advanced search click the gear icon to the left)'))
self.search.cleared.connect(self.search_box_cleared)
# Queued so that search.current_text will be correct
self.search.changed.connect(self.search_box_changed,
type=Qt.ConnectionType.QueuedConnection)
self.search.focus_to_library.connect(self.focus_to_library)
self.advanced_search_toggle_action.triggered.connect(self.do_advanced_search)
self.search.clear()
self.search.setMaximumWidth(self.width()-150)
self.action_focus_search = QAction(self)
shortcuts = list(
map(lambda x:unicode_type(x.toString(QKeySequence.SequenceFormat.PortableText)),
QKeySequence.keyBindings(QKeySequence.StandardKey.Find)))
shortcuts += ['/', 'Alt+S']
self.keyboard.register_shortcut('start search', _('Start search'),
default_keys=shortcuts, action=self.action_focus_search)
self.action_focus_search.triggered.connect(self.focus_search_box)
self.addAction(self.action_focus_search)
self.search.setStatusTip(re.sub(r'<\w+>', ' ',
unicode_type(self.search.toolTip())))
self.set_highlight_only_button_icon()
self.highlight_only_button.clicked.connect(self.highlight_only_clicked)
tt = _('Enable or disable search highlighting.') + '<br><br>'
tt += config.help('highlight_search_matches')
self.highlight_only_button.setToolTip(tt)
self.highlight_only_action = ac = QAction(self)
self.addAction(ac), ac.triggered.connect(self.highlight_only_clicked)
self.keyboard.register_shortcut('highlight search results', _('Highlight search results'), action=self.highlight_only_action)
def setModelData(self, editor, model, index):
self.closeEditor.emit(editor, QAbstractItemDelegate.EndEditHint.NoHint)
custom_keys = editor.custom_keys
sc = index.data(Qt.ItemDataRole.UserRole).data
if custom_keys is None:
candidates = []
for ckey in sc['default_keys']:
ckey = QKeySequence(ckey,
QKeySequence.SequenceFormat.PortableText)
matched = False
for s in editor.all_shortcuts:
if s is editor.shortcut:
continue
for k in s['keys']:
if k == ckey:
matched = True
break
if not matched:
candidates.append(ckey)
candidates = tuple(candidates)
sc['set_to_default'] = True
else:
sc['set_to_default'] = False
candidates = custom_keys
sc['keys'] = candidates
self.changed_signal.emit()
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(_('Set to undefined') + '\t' + QKeySequence(Qt.Key.Key_Space).toString(QKeySequence.SequenceFormat.NativeText),
self.clear_to_undefined)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m)
m.popup(ev.globalPos())
def contextMenuEvent(self, ev):
menu = self.createStandardContextMenu()
for action in menu.actions():
parts = action.text().split('\t')
if len(parts) == 2 and QKeySequence(QKeySequence.StandardKey.Paste).toString(QKeySequence.SequenceFormat.NativeText) in parts[-1]:
menu.insertAction(action, self.action_paste_and_match_style)
break
else:
menu.addAction(self.action_paste_and_match_style)
st = self.text()
m = QMenu(_('Fonts'))
m.addAction(self.action_bold), m.addAction(self.action_italic), m.addAction(self.action_underline)
menu.addMenu(m)
if st and st.strip():
self.create_change_case_menu(menu)
parent = self._parent()
if hasattr(parent, 'toolbars_visible'):
vis = parent.toolbars_visible
menu.addAction(_('%s toolbars') % (_('Hide') if vis else _('Show')), parent.toggle_toolbars)
menu.addSeparator()
am = QMenu(_('Advanced'))
menu.addMenu(am)
am.addAction(self.action_block_style)
am.addAction(self.action_insert_link)
am.addAction(self.action_background)
am.addAction(self.action_color)
menu.addAction(_('Smarten punctuation'), parent.smarten_punctuation)
menu.exec_(ev.globalPos())
def initialize(self, shortcut, all_shortcuts):
self.header.setText('<b>%s: %s</b>'%(_('Customize'), shortcut['name']))
self.all_shortcuts = all_shortcuts
self.shortcut = shortcut
self.default_keys = [QKeySequence(k, QKeySequence.SequenceFormat.PortableText) for k
in shortcut['default_keys']]
self.current_keys = list(shortcut['keys'])
default = ', '.join([str(k.toString(QKeySequence.SequenceFormat.NativeText)) for k in
self.default_keys])
if not default:
default = _('None')
current = ', '.join([str(k.toString(QKeySequence.SequenceFormat.NativeText)) for k in
self.current_keys])
if not current:
current = _('None')
self.use_default.setText(_('&Default: %(deflt)s [Currently not conflicting: %(curr)s]')%
dict(deflt=default, curr=current))
if shortcut['set_to_default']:
self.use_default.setChecked(True)
else:
self.use_custom.setChecked(True)
for key, which in zip(self.current_keys, [1,2]):
button = getattr(self, 'button%d'%which)
button.setText(key.toString(QKeySequence.SequenceFormat.NativeText))
def index_to_key_sequence(idx):
mods = []
for i, x in enumerate(('ALT', 'CTRL', 'META', 'SHIFT')):
if idx[i] == 'y':
mods.append(x.capitalize())
mods.append(idx[4:])
return QKeySequence('+'.join(mods))
def setEditorData(self, editor, index):
defs = index.data(DEFAULTS)
defs = _(' or ').join([str(x.toString(QKeySequence.SequenceFormat.NativeText)) for x in defs])
editor.key = str(index.data(KEY))
editor.default_shortcuts.setText(_('&Default') + ': %s' % defs)
editor.default_shortcuts.setChecked(True)
editor.header.setText('<b>%s: %s</b>'%(_('Customize shortcuts for'),
str(index.data(DESCRIPTION))))
custom = index.data(CUSTOM)
if custom:
editor.custom.setChecked(True)
for x in (0, 1):
button = getattr(editor, 'button%d'%(x+1))
if len(custom) > x:
seq = QKeySequence(custom[x])
button.setText(seq.toString(QKeySequence.SequenceFormat.NativeText))
setattr(editor, 'shortcut%d'%(x+1), seq)
def finalize(shortcuts, custom_keys_map={}): # {{{
'''
Resolve conflicts and assign keys to every action in shortcuts, which must
be a OrderedDict. User specified mappings of unique names to keys (as a
list of strings) should be passed in in custom_keys_map. Return a mapping
of unique names to resolved keys. Also sets the set_to_default member
correctly for each shortcut.
'''
seen, keys_map = {}, {}
for unique_name, shortcut in iteritems(shortcuts):
custom_keys = custom_keys_map.get(unique_name, None)
if custom_keys is None:
candidates = shortcut['default_keys']
shortcut['set_to_default'] = True
else:
candidates = custom_keys
shortcut['set_to_default'] = False
keys = []
for x in candidates:
ks = QKeySequence(x, QKeySequence.SequenceFormat.PortableText)
x = unicode_type(
ks.toString(QKeySequence.SequenceFormat.PortableText))
if x in seen:
if DEBUG:
prints('Key %r for shortcut %s is already used by'
' %s, ignoring' %
(x, shortcut['name'], seen[x]['name']))
keys_map[unique_name] = ()
continue
seen[x] = shortcut
keys.append(ks)
keys = tuple(keys)
keys_map[unique_name] = keys
ac = shortcut['action']
if ac is None or sip.isdeleted(ac):
if ac is not None and DEBUG:
prints('Shortcut %r has a deleted action' % unique_name)
continue
ac.setShortcuts(list(keys))
return keys_map
def r(name, icon, text, checkable=False, shortcut=None):
ac = QAction(QIcon(I(icon + '.png')), text, self)
if checkable:
ac.setCheckable(checkable)
setattr(self, 'action_'+name, ac)
ac.triggered.connect(getattr(self, 'do_' + name))
if shortcut is not None:
sc = shortcut if isinstance(shortcut, QKeySequence) else QKeySequence(shortcut)
ac.setShortcut(sc)
ac.setToolTip(text + f' [{sc.toString(QKeySequence.SequenceFormat.NativeText)}]')
self.addAction(ac)
def test():
setup_for_cli_run()
app = QApplication([])
bus = dbus.SessionBus()
dbus_name = BusName('com.calibre-ebook.TestDBusMenu',
bus=bus,
do_not_queue=True)
m = QMenu()
ac = m.addAction(QIcon(I('window-close.png')), 'Quit', app.quit)
ac.setShortcut(QKeySequence('Ctrl+Q'))
menu = DBusMenu('/Menu', bus=bus)
menu.publish_new_menu(m)
app.exec_()
del dbus_name
def __init__(self, shortcuts, config_file_base_name, parent=None):
QAbstractListModel.__init__(self, parent)
self.descriptions = {}
for k, v in shortcuts.items():
self.descriptions[k] = v[-1]
self.keys = {}
for k, v in shortcuts.items():
self.keys[k] = v[0]
self.order = list(shortcuts)
self.order.sort(key=lambda x: sort_key(self.descriptions[x]))
self.sequences = {}
for k, v in self.keys.items():
self.sequences[k] = [QKeySequence(x) for x in v]
self.custom = XMLConfig(config_file_base_name)
def key_sequence_to_dbus_shortcut(qks):
for key in qks:
if key == -1 or key == Qt.Key.Key_unknown:
continue
items = []
for mod, name in iteritems({
Qt.Modifier.META: 'Super',
Qt.Modifier.CTRL: 'Control',
Qt.Modifier.ALT: 'Alt',
Qt.Modifier.SHIFT: 'Shift'
}):
if key & mod == mod:
items.append(name)
key &= int(~(Qt.KeyboardModifier.ShiftModifier
| Qt.KeyboardModifier.ControlModifier
| Qt.KeyboardModifier.AltModifier
| Qt.KeyboardModifier.MetaModifier
| Qt.KeyboardModifier.KeypadModifier))
text = QKeySequence(key).toString()
if text:
text = {'+': 'plus', '-': 'minus'}.get(text, text)
items.append(text)
if items:
yield items
def access_key(k):
'Return shortcut text suitable for adding to a menu item'
if QKeySequence.keyBindings(k):
return '\t' + QKeySequence(k).toString(
QKeySequence.SequenceFormat.NativeText)
return ''
def key(k):
sc = unicode_type(
QKeySequence(k | Qt.Modifier.CTRL).toString(
QKeySequence.SequenceFormat.NativeText))
return ' [%s]' % sc
def key_to_text(key):
return QKeySequence(key).toString(
QKeySequence.SequenceFormat.PortableText).lower()
def key(k):
sc = str(QKeySequence(k | Qt.KeyboardModifier.ControlModifier).toString(QKeySequence.SequenceFormat.NativeText))
return ' [%s]'%sc
def __init__(self,
ids,
get_metadata,
field_metadata,
parent=None,
window_title=None,
reject_button_tooltip=None,
accept_all_tooltip=None,
reject_all_tooltip=None,
revert_tooltip=None,
intro_msg=None,
action_button=None,
**kwargs):
QDialog.__init__(self, parent)
self.l = l = QVBoxLayout()
self.next_called = False
self.setLayout(l)
self.setWindowIcon(QIcon(I('auto_author_sort.png')))
self.get_metadata = get_metadata
self.ids = list(ids)
self.total = len(self.ids)
self.accepted = OrderedDict()
self.rejected_ids = set()
self.window_title = window_title or _('Compare metadata')
if intro_msg:
self.la = la = QLabel(intro_msg)
la.setWordWrap(True)
l.addWidget(la)
self.compare_widget = CompareSingle(field_metadata,
parent=parent,
revert_tooltip=revert_tooltip,
**kwargs)
self.sa = sa = QScrollArea()
l.addWidget(sa)
sa.setWidget(self.compare_widget)
sa.setWidgetResizable(True)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Cancel)
bb.button(QDialogButtonBox.StandardButton.Cancel).setAutoDefault(False)
bb.rejected.connect(self.reject)
if self.total > 1:
self.aarb = b = bb.addButton(_('&Accept all remaining'),
QDialogButtonBox.ButtonRole.YesRole)
b.setIcon(QIcon(I('ok.png'))), b.setAutoDefault(False)
if accept_all_tooltip:
b.setToolTip(accept_all_tooltip)
b.clicked.connect(self.accept_all_remaining)
self.rarb = b = bb.addButton(
_('Re&ject all remaining'),
QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon(I('minus.png'))), b.setAutoDefault(False)
if reject_all_tooltip:
b.setToolTip(reject_all_tooltip)
b.clicked.connect(self.reject_all_remaining)
self.sb = b = bb.addButton(_('R&eject'),
QDialogButtonBox.ButtonRole.ActionRole)
connect_lambda(b.clicked, self, lambda self: self.next_item(False))
b.setIcon(QIcon(I('minus.png'))), b.setAutoDefault(False)
if reject_button_tooltip:
b.setToolTip(reject_button_tooltip)
self.next_action = ac = QAction(self)
ac.setShortcut(QKeySequence(Qt.Modifier.ALT | Qt.Key.Key_Right))
self.addAction(ac)
if action_button is not None:
self.acb = b = bb.addButton(action_button[0],
QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon(action_button[1]))
self.action_button_action = action_button[2]
b.clicked.connect(self.action_button_clicked)
self.nb = b = bb.addButton(
_('&Next') if self.total > 1 else _('&OK'),
QDialogButtonBox.ButtonRole.ActionRole)
if self.total > 1:
b.setToolTip(
_('Move to next [%s]') % self.next_action.shortcut().toString(
QKeySequence.SequenceFormat.NativeText))
self.next_action.triggered.connect(b.click)
b.setIcon(QIcon(I('forward.png' if self.total > 1 else 'ok.png')))
connect_lambda(b.clicked, self, lambda self: self.next_item(True))
b.setDefault(True), b.setAutoDefault(True)
self.bbh = h = QHBoxLayout()
h.setContentsMargins(0, 0, 0, 0)
l.addLayout(h)
self.markq = m = QCheckBox(_('&Mark rejected books'))
m.setChecked(gprefs['metadata_diff_mark_rejected'])
connect_lambda(
m.stateChanged[int], self, lambda self: gprefs.set(
'metadata_diff_mark_rejected', self.markq.isChecked()))
m.setToolTip(
_('Mark rejected books in the book list after this dialog is closed'
))
h.addWidget(m), h.addWidget(bb)
self.next_item(True)
desktop = QApplication.instance().desktop()
geom = desktop.availableGeometry(parent or self)
width = max(700, min(950, geom.width() - 50))
height = max(650, min(1000, geom.height() - 100))
self.resize(QSize(width, height))
geom = gprefs.get('diff_dialog_geom', None)
if geom is not None:
QApplication.instance().safe_restore_geometry(self, geom)
b.setFocus(Qt.FocusReason.OtherFocusReason)
self.next_called = False
def __init__(self):
QMainWindow.__init__(self)
f = factory()
self.setMinimumWidth(400)
self.setWindowTitle('Demo of DBUS menu exporter and systray integration')
self.statusBar().showMessage(self.windowTitle())
w = QWidget(self)
self.setCentralWidget(w)
self.l = l = QVBoxLayout(w)
mb = self.menu_bar = f.create_window_menubar(self)
m = self.menu_one = mb.addMenu('&One')
m.aboutToShow.connect(self.about_to_show_one)
s = self.style()
self.q = q = QAction('&Quit', self)
q.setShortcut(QKeySequence.StandardKey.Quit), q.setIcon(s.standardIcon(QStyle.StandardPixmap.SP_DialogCancelButton))
q.triggered.connect(QApplication.quit)
self.addAction(q)
QApplication.instance().setWindowIcon(s.standardIcon(QStyle.StandardPixmap.SP_ComputerIcon))
for i, icon in zip(range(3), map(s.standardIcon, (
QStyle.StandardPixmap.SP_DialogOkButton, QStyle.StandardPixmap.SP_DialogHelpButton, QStyle.StandardPixmap.SP_ArrowUp))):
ac = m.addAction('One - &%d' % (i + 1))
ac.setShortcut(QKeySequence(Qt.Modifier.CTRL | (Qt.Key.Key_1 + i), Qt.Modifier.SHIFT | (Qt.Key.Key_1 + i)))
ac.setIcon(icon)
m.addSeparator()
self.menu_two = m2 = m.addMenu('A &submenu')
for i, icon in zip(range(3), map(s.standardIcon, (
QStyle.StandardPixmap.SP_DialogOkButton, QStyle.StandardPixmap.SP_DialogCancelButton, QStyle.StandardPixmap.SP_ArrowUp))):
ac = m2.addAction('Two - &%d' % (i + 1))
ac.setShortcut(QKeySequence(Qt.Modifier.CTRL | (Qt.Key.Key_A + i)))
ac.setIcon(icon)
m2.aboutToShow.connect(self.about_to_show_two)
m2.addSeparator(), m.addSeparator()
m.addAction('&Disabled action').setEnabled(False)
ac = m.addAction('A checkable action')
make_checkable(ac)
g = QActionGroup(self)
make_checkable(g.addAction(m.addAction('Exclusive 1')))
make_checkable(g.addAction(m.addAction('Exclusive 2')), False)
m.addSeparator()
self.about_to_show_sentinel = m.addAction('This action\'s text should change before menu is shown')
self.as_count = 0
for ac in mb.findChildren(QAction):
ac.triggered.connect(self.action_triggered)
for m in mb.findChildren(QMenu):
m.aboutToShow.connect(self.about_to_show)
self.systray = f.create_system_tray_icon(parent=self, title=self.windowTitle())
if self.systray is not None:
self.systray.activated.connect(self.tray_activated)
self.sm = m = QMenu()
m.addAction('Show/hide main window').triggered.connect(self.tray_activated)
m.addAction(q)
self.systray.setContextMenu(m)
self.update_tray_toggle_action()
self.cib = b = QPushButton('Change system tray icon')
l.addWidget(b), b.clicked.connect(self.change_icon)
self.hib = b = QPushButton('Show/Hide system tray icon')
l.addWidget(b), b.clicked.connect(self.systray.toggle)
self.update_tooltip_timer = t = QTimer(self)
t.setInterval(1000), t.timeout.connect(self.update_tooltip), t.start()
self.ab = b = QPushButton('Add a new menu')
b.clicked.connect(self.add_menu), l.addWidget(b)
self.rb = b = QPushButton('Remove a created menu')
b.clicked.connect(self.remove_menu), l.addWidget(b)
self.sd = b = QPushButton('Show modal dialog')
b.clicked.connect(self.show_dialog), l.addWidget(b)
print('DBUS connection unique name:', f.bus.get_unique_name())
def __init__(self, parent=None):
QTextEdit.__init__(self, parent)
self.setTabChangesFocus(True)
self.document().setDefaultStyleSheet(
css() + '\n\nli { margin-top: 0.5ex; margin-bottom: 0.5ex; }')
font = self.font()
f = QFontInfo(font)
delta = tweaks['change_book_details_font_size_by'] + 1
if delta:
font.setPixelSize(f.pixelSize() + delta)
self.setFont(font)
f = QFontMetrics(self.font())
self.em_size = f.horizontalAdvance('m')
self.base_url = None
self._parent = weakref.ref(parent)
self.comments_pat = re.compile(r'<!--.*?-->', re.DOTALL)
def r(name, icon, text, checkable=False, shortcut=None):
ac = QAction(QIcon(I(icon + '.png')), text, self)
ac.setShortcutContext(
Qt.ShortcutContext.WidgetWithChildrenShortcut)
if checkable:
ac.setCheckable(checkable)
setattr(self, 'action_' + name, ac)
ac.triggered.connect(getattr(self, 'do_' + name))
if shortcut is not None:
sc = shortcut if isinstance(
shortcut, QKeySequence) else QKeySequence(shortcut)
ac.setShortcut(sc)
ac.setToolTip(
text +
f' [{sc.toString(QKeySequence.SequenceFormat.NativeText)}]'
)
self.addAction(ac)
r('bold', 'format-text-bold', _('Bold'), True,
QKeySequence.StandardKey.Bold)
r('italic', 'format-text-italic', _('Italic'), True,
QKeySequence.StandardKey.Italic)
r('underline', 'format-text-underline', _('Underline'), True,
QKeySequence.StandardKey.Underline)
r('strikethrough', 'format-text-strikethrough', _('Strikethrough'),
True)
r('superscript', 'format-text-superscript', _('Superscript'), True)
r('subscript', 'format-text-subscript', _('Subscript'), True)
r('ordered_list', 'format-list-ordered', _('Ordered list'), True)
r('unordered_list', 'format-list-unordered', _('Unordered list'), True)
r('align_left', 'format-justify-left', _('Align left'), True)
r('align_center', 'format-justify-center', _('Align center'), True)
r('align_right', 'format-justify-right', _('Align right'), True)
r('align_justified', 'format-justify-fill', _('Align justified'), True)
r('undo',
'edit-undo',
_('Undo'),
shortcut=QKeySequence.StandardKey.Undo)
r('redo',
'edit-redo',
_('Redo'),
shortcut=QKeySequence.StandardKey.Redo)
r('remove_format', 'edit-clear', _('Remove formatting'))
r('copy',
'edit-copy',
_('Copy'),
shortcut=QKeySequence.StandardKey.Copy)
r('paste',
'edit-paste',
_('Paste'),
shortcut=QKeySequence.StandardKey.Paste)
r('paste_and_match_style', 'edit-paste', _('Paste and match style'))
r('cut', 'edit-cut', _('Cut'), shortcut=QKeySequence.StandardKey.Cut)
r('indent', 'format-indent-more', _('Increase indentation'))
r('outdent', 'format-indent-less', _('Decrease indentation'))
r('select_all',
'edit-select-all',
_('Select all'),
shortcut=QKeySequence.StandardKey.SelectAll)
r('color', 'format-text-color', _('Foreground color'))
r('background', 'format-fill-color', _('Background color'))
r('insert_link',
'insert-link',
_('Insert link or image'),
shortcut=QKeySequence('Ctrl+l',
QKeySequence.SequenceFormat.PortableText))
r(
'insert_hr',
'format-text-hr',
_('Insert separator'),
)
r('clear', 'trash', _('Clear'))
self.action_block_style = QAction(QIcon(I('format-text-heading.png')),
_('Style text block'), self)
self.action_block_style.setToolTip(_('Style the selected text block'))
self.block_style_menu = QMenu(self)
self.action_block_style.setMenu(self.block_style_menu)
self.block_style_actions = []
h = _('Heading {0}')
for text, name in (
(_('Normal'), 'p'),
(h.format(1), 'h1'),
(h.format(2), 'h2'),
(h.format(3), 'h3'),
(h.format(4), 'h4'),
(h.format(5), 'h5'),
(h.format(6), 'h6'),
(_('Blockquote'), 'blockquote'),
):
ac = QAction(text, self)
self.block_style_menu.addAction(ac)
ac.block_name = name
ac.setCheckable(True)
self.block_style_actions.append(ac)
ac.triggered.connect(self.do_format_block)
self.setHtml('')
self.copyAvailable.connect(self.update_clipboard_actions)
self.update_clipboard_actions(False)
self.selectionChanged.connect(self.update_selection_based_actions)
self.update_selection_based_actions()
connect_lambda(self.undoAvailable, self,
lambda self, yes: self.action_undo.setEnabled(yes))
connect_lambda(self.redoAvailable, self,
lambda self, yes: self.action_redo.setEnabled(yes))
self.action_undo.setEnabled(False), self.action_redo.setEnabled(False)
self.textChanged.connect(self.update_cursor_position_actions)
self.cursorPositionChanged.connect(self.update_cursor_position_actions)
self.textChanged.connect(self.data_changed)
self.update_cursor_position_actions()
def create_action(self,
spec=None,
attr='qaction',
shortcut_name=None,
persist_shortcut=False):
if spec is None:
spec = self.action_spec
text, icon, tooltip, shortcut = spec
if icon is not None:
action = QAction(QIcon(I(icon)), text, self.gui)
else:
action = QAction(text, self.gui)
if attr == 'qaction':
if hasattr(self.action_menu_clone_qaction, 'rstrip'):
mt = str(self.action_menu_clone_qaction)
else:
mt = action.text()
self.menuless_qaction = ma = QAction(action.icon(), mt, self.gui)
ma.triggered.connect(action.trigger)
for a in ((action, ma) if attr == 'qaction' else (action, )):
a.setAutoRepeat(self.auto_repeat)
text = tooltip if tooltip else text
a.setToolTip(text)
a.setStatusTip(text)
a.setWhatsThis(text)
shortcut_action = action
desc = tooltip if tooltip else None
if attr == 'qaction':
shortcut_action = ma
if shortcut is not None:
keys = ((shortcut, ) if isinstance(shortcut, string_or_bytes) else
tuple(shortcut))
if shortcut_name is None and spec[0]:
shortcut_name = str(spec[0])
if shortcut_name and self.action_spec[0] and not (
attr == 'qaction' and self.popup_type
== QToolButton.ToolButtonPopupMode.InstantPopup):
try:
self.gui.keyboard.register_shortcut(
self.unique_name + ' - ' + attr,
shortcut_name,
default_keys=keys,
action=shortcut_action,
description=desc,
group=self.action_spec[0],
persist_shortcut=persist_shortcut)
except NameConflict as e:
try:
prints(str(e))
except:
pass
shortcut_action.setShortcuts([
QKeySequence(key,
QKeySequence.SequenceFormat.PortableText)
for key in keys
])
else:
self.shortcut_action_for_context_menu = shortcut_action
if ismacos:
# In Qt 5 keyboard shortcuts dont work unless the
# action is explicitly added to the main window
self.gui.addAction(shortcut_action)
if attr is not None:
setattr(self, attr, action)
if attr == 'qaction' and self.action_add_menu:
menu = QMenu()
action.setMenu(menu)
if self.action_menu_clone_qaction:
menu.addAction(self.menuless_qaction)
return 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 debug_event(self, ev):
from calibre.gui2 import event_type_name
print('Event:', event_type_name(ev))
if ev.type() in (QEvent.Type.KeyPress, QEvent.Type.ShortcutOverride,
QEvent.Type.KeyRelease):
print('\tkey:', QKeySequence(ev.key()).toString())