def __init__(self):
self.search.initialize(
'main_search_history',
colorize=True,
help_text=_(
'Search (For Advanced Search click the button 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.QueuedConnection)
self.search.focus_to_library.connect(self.focus_to_library)
self.clear_button.clicked.connect(self.search.clear_clicked)
self.advanced_search_button.clicked[bool].connect(
self.do_advanced_search)
self.search.clear()
self.search.setMaximumWidth(self.width() - 150)
self.action_focus_search = QAction(self)
shortcuts = QKeySequence.keyBindings(QKeySequence.Find)
shortcuts = list(shortcuts) + [
QKeySequence('/'), QKeySequence('Alt+S')
]
self.action_focus_search.setShortcuts(shortcuts)
self.action_focus_search.triggered.connect(self.focus_search_box)
self.addAction(self.action_focus_search)
self.search.setStatusTip(
re.sub(r'<\w+>', ' ', unicode(self.search.toolTip())))
self.advanced_search_button.setStatusTip(
self.advanced_search_button.toolTip())
self.clear_button.setStatusTip(self.clear_button.toolTip())
self.search_highlight_only.stateChanged.connect(
self.highlight_only_changed)
self.search_highlight_only.setChecked(
dynamic.get('search_highlight_only', False))
def key_press_event(self, ev, which=0):
code = ev.key()
if self.capture == 0 or code in (
0,
Qt.Key_unknown,
Qt.Key_Shift,
Qt.Key_Control,
Qt.Key_Alt,
Qt.Key_Meta,
Qt.Key_AltGr,
Qt.Key_CapsLock,
Qt.Key_NumLock,
Qt.Key_ScrollLock,
):
return QWidget.keyPressEvent(self, ev)
button = getattr(self, "button%d" % which)
button.setStyleSheet("QPushButton { font-weight: normal}")
mods = int(ev.modifiers()) & ~Qt.KeypadModifier
txt = unicode(ev.text())
if txt and txt.lower() == txt.upper():
# We have a symbol like ! or > etc. In this case the value of code
# already includes Shift, so remove it
mods &= ~Qt.ShiftModifier
sequence = QKeySequence(code | mods)
button.setText(sequence.toString(QKeySequence.NativeText))
self.capture = 0
dup_desc = self.dup_check(sequence)
if dup_desc is not None:
error_dialog(
self,
_("Already assigned"),
unicode(sequence.toString(QKeySequence.NativeText)) + " " + _("already assigned to") + " " + dup_desc,
show=True,
)
self.clear_clicked(which=which)
def key_press_event(self, ev, which=0):
code = ev.key()
if self.capture == 0 or code in (0, Qt.Key_unknown, Qt.Key_Shift,
Qt.Key_Control, Qt.Key_Alt,
Qt.Key_Meta, Qt.Key_AltGr,
Qt.Key_CapsLock, Qt.Key_NumLock,
Qt.Key_ScrollLock):
return QWidget.keyPressEvent(self, ev)
button = getattr(self, 'button%d' % which)
button.setStyleSheet('QPushButton { font-weight: normal}')
mods = int(ev.modifiers()) & ~Qt.KeypadModifier
txt = unicode(ev.text())
if txt and txt.lower() == txt.upper():
# We have a symbol like ! or > etc. In this case the value of code
# already includes Shift, so remove it
mods &= ~Qt.ShiftModifier
sequence = QKeySequence(code | mods)
button.setText(sequence.toString(QKeySequence.NativeText))
self.capture = 0
dup_desc = self.dup_check(sequence)
if dup_desc is not None:
error_dialog(self,
_('Already assigned'),
unicode(sequence.toString(QKeySequence.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 = QGridLayout(self)
self.setLayout(l)
self.setWindowTitle(_('Trim Image'))
self.bar = b = QToolBar(self)
l.addWidget(b)
b.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
b.setIconSize(QSize(32, 32))
self.msg = la = QLabel('\xa0' + _(
'Select a region by dragging with your mouse on the image, and then click trim'
))
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.Undo))
self.redo_action = r = c.redo_action
r.setShortcut(QKeySequence(QKeySequence.Redo))
self.trim_action = ac = self.bar.addAction(QIcon(I('trim.png')),
_('&Trim'), c.trim_image)
ac.setShortcut(QKeySequence('Ctrl+T'))
ac.setToolTip(
'%s [%s]' %
(_('Trim image by removing borders outside the selected region'),
ac.shortcut().toString(QKeySequence.NativeText)))
ac.setEnabled(False)
c.selection_state_changed.connect(self.selection_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.Ok
| QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb)
self.tok = b = bb.addButton(_('Trim and OK'),
QDialogButtonBox.ActionRole)
b.clicked.connect(self.trim_and_accept)
b.setIcon(self.trim_action.icon())
self.resize(QSize(900, 600))
geom = gprefs.get('image-trim-dialog-geometry', None)
if geom is not None:
self.restoreGeometry(geom)
self.setWindowIcon(self.trim_action.icon())
self.image_data = None
def setupUi(self, *args): # {{{
self.resize(990, 670)
self.download_shortcut = QShortcut(self)
self.download_shortcut.setKey(
QKeySequence('Ctrl+D', QKeySequence.PortableText))
p = self.parent()
if hasattr(p, 'keyboard'):
kname = u'Interface Action: Edit Metadata (Edit Metadata) : menu action : download'
sc = p.keyboard.keys_map.get(kname, None)
if sc:
self.download_shortcut.setKey(sc[0])
self.button_box = bb = QDialogButtonBox(self)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
self.next_button = QPushButton(QIcon(I('forward.png')), _('Next'),
self)
self.next_button.setShortcut(QKeySequence('Alt+Right'))
self.next_button.clicked.connect(self.next_clicked)
self.prev_button = QPushButton(QIcon(I('back.png')), _('Previous'),
self)
self.prev_button.setShortcut(QKeySequence('Alt+Left'))
self.button_box.addButton(self.prev_button, bb.ActionRole)
self.button_box.addButton(self.next_button, bb.ActionRole)
self.prev_button.clicked.connect(self.prev_clicked)
bb.setStandardButtons(bb.Ok | bb.Cancel)
bb.button(bb.Ok).setDefault(True)
self.scroll_area = QScrollArea(self)
self.scroll_area.setFrameShape(QScrollArea.NoFrame)
self.scroll_area.setWidgetResizable(True)
self.central_widget = QTabWidget(self)
self.scroll_area.setWidget(self.central_widget)
self.l = QVBoxLayout(self)
self.setLayout(self.l)
self.l.addWidget(self.scroll_area)
ll = self.button_box_layout = QHBoxLayout()
self.l.addLayout(ll)
ll.addSpacing(10)
ll.addWidget(self.button_box)
self.setWindowIcon(QIcon(I('edit_input.png')))
self.setWindowTitle(BASE_TITLE)
self.create_basic_metadata_widgets()
if len(self.db.custom_column_label_map):
self.create_custom_metadata_widgets()
self.do_layout()
geom = gprefs.get('metasingle_window_geometry3', None)
if geom is not None:
self.restoreGeometry(bytes(geom))
def __init__(self, parent):
QMenuBar.__init__(self, parent)
# Menu items
self._fileM = QMenu(self.tr("File"))
self._editM = QMenu(self.tr("Edit"))
self._viewM = QMenu(self.tr("View"))
self._optionM = QMenu(self.tr("Options"))
self.addMenu(self._fileM)
self.addMenu(self._editM)
self.addMenu(self._viewM)
self.addMenu(self._optionM)
# Actions
self._connectDatabaseA = QAction(self.tr("Connect a PostGIS database"),
self.parent())
self._connectDatabaseA.setShortcut(QKeySequence("Ctrl+Shift+C"))
self.parent().connect(self._connectDatabaseA, SIGNAL("triggered()"),
self.parent().dialConnectDatabase)
self._importDatabaseDataA = QAction(
self.tr("Import data from database"), self.parent())
self._importDatabaseDataA.setShortcut(QKeySequence("Ctrl+Shift+I"))
self.parent().connect(self._importDatabaseDataA, SIGNAL("triggered()"),
self.parent().dialImportDatabaseData)
self._importVectorFileDataA = QAction(
self.tr("Import vector from file"), self.parent())
self._importVectorFileDataA.setShortcut(QKeySequence("Ctrl+Shift+V"))
self.parent().connect(self._importVectorFileDataA,
SIGNAL("triggered()"),
self.parent().dialImportVectorFileData)
self._importRasterFileDataA = QAction(
self.tr("Import raster data from file"), self.parent())
self._importRasterFileDataA.setShortcut(QKeySequence("Ctrl+Shift+R"))
self.parent().connect(self._importRasterFileDataA,
SIGNAL("triggered()"),
self.parent().dialImportRasterFileData)
self._colorLayerA = QAction(self.tr("Select layer color"),
self.parent())
self.parent().connect(self._colorLayerA, SIGNAL("triggered()"),
self.parent().dialSelectLayerColor)
# Add actions to menu
self._fileM.addAction(self._importVectorFileDataA)
self._fileM.addAction(self._importRasterFileDataA)
self._fileM.addSeparator()
self._fileM.addAction(self._connectDatabaseA)
self._fileM.addAction(self._importDatabaseDataA)
self._viewM.addAction(self._colorLayerA)
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.KeypadModifier))
for key in self.order:
if key not in ignore:
for seq in self.get_sequences(key):
if seq.matches(q) == QKeySequence.ExactMatch:
return key
return None
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(button.text())
if t == _('None'):
continue
ks = QKeySequence(t, QKeySequence.NativeText)
if not ks.isEmpty():
ans.append(ks)
return tuple(ans)
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(button.text())
if t == _('None'):
continue
ks = QKeySequence(t, QKeySequence.NativeText)
if not ks.isEmpty():
ans.append(ks)
return tuple(ans)
def __init__(self):
self.search.initialize('main_search_history', colorize=True,
help_text=_('Search (For Advanced Search click the button 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.QueuedConnection)
self.search.focus_to_library.connect(self.focus_to_library)
self.clear_button.clicked.connect(self.search.clear_clicked)
self.advanced_search_button.clicked[bool].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(x.toString()),
QKeySequence.keyBindings(QKeySequence.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(self.search.toolTip())))
self.advanced_search_button.setStatusTip(self.advanced_search_button.toolTip())
self.clear_button.setStatusTip(self.clear_button.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)
def setModelData(self, editor, model, index):
self.closeEditor.emit(editor, self.NoHint)
custom_keys = editor.custom_keys
sc = index.data(Qt.UserRole).toPyObject().data
if custom_keys is None:
candidates = []
for ckey in sc['default_keys']:
ckey = QKeySequence(ckey, QKeySequence.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 toggleTetris(self):
self.tetris = Dialog(_("Tetris"), None, True, QKeySequence(Qt.Key_F6))
_tetris = Tetris(self.tetris)
self.tetris.addWidget(_tetris)
self.tetris.resize(240, 500)
_tetris.start()
self.tetris.exec_()
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.PortableText)
for k in shortcut['default_keys']
]
self.current_keys = list(shortcut['keys'])
default = ', '.join(
[unicode(k.toString(k.NativeText)) for k in self.default_keys])
if not default:
default = _('None')
current = ', '.join(
[unicode(k.toString(k.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(key.NativeText))
def create_action(self, spec=None, attr='qaction', shortcut_name=None):
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':
mt = (action.text() if self.action_menu_clone_qaction is True else
unicode(self.action_menu_clone_qaction))
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, basestring) else tuple(shortcut))
if shortcut_name is None and spec[0]:
shortcut_name = unicode(spec[0])
if shortcut_name and self.action_spec[0] and not (
attr == 'qaction'
and self.popup_type == QToolButton.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])
except NameConflict as e:
try:
prints(unicode(e))
except:
pass
shortcut_action.setShortcuts([
QKeySequence(key, QKeySequence.PortableText)
for key in keys
])
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 toggleConsole(self):
if not self.terminal:
terminal = QTermWidget()
terminal.setScrollBarPosition(QTermWidget.ScrollBarRight)
terminal.setColorScheme(1)
terminal.sendText("export TERM='xterm'\nclear\n")
self.terminal = Dialog(_("Terminal"), terminal, True, QKeySequence(Qt.Key_F11))
self.terminal.resize(700, 500)
self.terminal.exec_()
def setEditorData(self, editor, index):
defs = index.data(DEFAULTS).toPyObject()
defs = _(' or ').join(
[unicode(x.toString(x.NativeText)) for x in defs])
editor.key = unicode(index.data(KEY).toString())
editor.default_shortcuts.setText(_('&Default') + ': %s' % defs)
editor.default_shortcuts.setChecked(True)
editor.header.setText('<b>%s: %s</b>' %
(_('Customize shortcuts for'),
unicode(index.data(DESCRIPTION).toString())))
custom = index.data(CUSTOM).toPyObject()
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(seq.NativeText))
setattr(editor, 'shortcut%d' % (x + 1), seq)
def __init__(self, parent, view, row, link_delegate):
QDialog.__init__(self, parent)
Ui_BookInfo.__init__(self)
self.setupUi(self)
self.gui = parent
self.cover_pixmap = None
self.details.sizeHint = self.details_size_hint
self.details.page().setLinkDelegationPolicy(self.details.page().DelegateAllLinks)
self.details.linkClicked.connect(self.link_clicked)
self.css = P('templates/book_details.css', data=True).decode('utf-8')
self.link_delegate = link_delegate
self.details.setAttribute(Qt.WA_OpaquePaintEvent, False)
palette = self.details.palette()
self.details.setAcceptDrops(False)
palette.setBrush(QPalette.Base, Qt.transparent)
self.details.page().setPalette(palette)
self.view = view
self.current_row = None
self.fit_cover.setChecked(dynamic.get('book_info_dialog_fit_cover',
True))
self.refresh(row)
self.connect(self.view.selectionModel(), SIGNAL('currentChanged(QModelIndex,QModelIndex)'), self.slave)
self.connect(self.next_button, SIGNAL('clicked()'), self.next)
self.connect(self.previous_button, SIGNAL('clicked()'), self.previous)
self.fit_cover.stateChanged.connect(self.toggle_cover_fit)
self.cover.resizeEvent = self.cover_view_resized
self.cover.cover_changed.connect(self.cover_changed)
self.ns = QShortcut(QKeySequence('Alt+Right'), self)
self.ns.activated.connect(self.next)
self.ps = QShortcut(QKeySequence('Alt+Left'), self)
self.ps.activated.connect(self.previous)
self.next_button.setToolTip(_('Next [%s]')%
unicode(self.ns.key().toString(QKeySequence.NativeText)))
self.previous_button.setToolTip(_('Previous [%s]')%
unicode(self.ps.key().toString(QKeySequence.NativeText)))
desktop = QCoreApplication.instance().desktop()
screen_height = desktop.availableGeometry().height() - 100
self.resize(self.size().width(), screen_height)
def finalize(shortcuts, custom_keys_map={}): # {{{
"""
Resolve conflicts and assign keys to every action in shorcuts, 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 shortcuts.iteritems():
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.PortableText)
x = unicode(ks.toString(QKeySequence.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)
# print (111111, unique_name, candidates, keys)
keys_map[unique_name] = keys
ac = shortcut["action"]
if ac is not None:
ac.setShortcuts(list(keys))
return keys_map
def finalize(shortcuts, custom_keys_map={}): # {{{
'''
Resolve conflicts and assign keys to every action in shorcuts, 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 shortcuts.iteritems():
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.PortableText)
x = unicode(ks.toString(QKeySequence.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)
#print (111111, unique_name, candidates, keys)
keys_map[unique_name] = keys
ac = shortcut['action']
if ac is not None:
ac.setShortcuts(list(keys))
return keys_map
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', bytearray(''))
geom = QByteArray(geom)
if not self.restoreGeometry(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.PortableText),
QKeySequence('Ctrl+Shift+F', QKeySequence.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.PortableText)])
self.pre_fs_geom = None
cover_flow.setFocus(Qt.OtherFocusReason)
self.view_action = a = QAction(self)
iactions = parent.iactions
self.addAction(a)
a.setShortcuts(
list(iactions['View'].menuless_qaction.shortcuts()) +
[QKeySequence(Qt.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 __init__(self, parent, unique_pref_name, stays_on_top=False):
if stays_on_top:
QDialog.__init__(self, parent.opts.gui, Qt.WindowStaysOnTopHint)
else:
QDialog.__init__(self, parent.opts.gui)
self.unique_pref_name = unique_pref_name
self.prefs = parent.opts.prefs
self.geom = self.prefs.get(unique_pref_name, None)
self.finished.connect(self.dialog_closing)
# Hook ESC key
self.esc_action = a = QAction(self)
self.addAction(a)
a.triggered.connect(self.esc)
a.setShortcuts([QKeySequence('Esc', QKeySequence.PortableText)])
def key_press_event(self, ev, which=0):
code = ev.key()
if self.capture == 0 or code in (0, Qt.Key_unknown, Qt.Key_Shift,
Qt.Key_Control, Qt.Key_Alt,
Qt.Key_Meta, Qt.Key_AltGr,
Qt.Key_CapsLock, Qt.Key_NumLock,
Qt.Key_ScrollLock):
return QWidget.keyPressEvent(self, ev)
button = getattr(self, 'button%d' % which)
font = QFont()
button.setFont(font)
sequence = QKeySequence(code
| (int(ev.modifiers()) & ~Qt.KeypadModifier))
button.setText(sequence.toString())
self.capture = 0
setattr(self, 'shortcut%d' % which, sequence)
dup_desc = self.dup_check(sequence, self.key)
if dup_desc is not None:
error_dialog(self,
_('Already assigned'),
unicode(sequence.toString()) + ' ' +
_('already assigned to') + ' ' + dup_desc,
show=True)
self.clear_clicked(which=which)
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 setZ(self, z, top=False, depthlabel=None, can_raise=True):
self.image.setZ(z)
if self._z_markers is None:
for i, elem in enumerate(self._all_markers):
elem.setZ(z + i + i)
# set the depth label, if any
label = "%s: %s" % (chr(ord('a') + self._number), self.name)
# label = "%s %s"%(depthlabel,self.name) if depthlabel else self.name
if top:
label = "%s: <B>%s</B>" % (chr(ord('a') + self._number), self.name)
self._wlabel.setText(label)
# set hotkey
self._qa_show_rc.setShortcut(Qt.Key_F9 if top else QKeySequence())
# set raise control
self._can_raise = can_raise
self._qa_raise.setVisible(can_raise)
self._wlock.setVisible(can_raise)
if can_raise:
self._wraise.setToolTip(
"<P>Click here to raise this image to the top. Click on the down-arrow to access the image menu.</P>")
else:
self._wraise.setToolTip("<P>Click to access the image menu.</P>")
def __init__(self):
self.search.initialize(
'main_search_history',
colorize=True,
help_text=_(
'Search (For Advanced Search click the button 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.QueuedConnection)
self.search.focus_to_library.connect(self.focus_to_library)
self.clear_button.clicked.connect(self.search.clear_clicked)
self.advanced_search_button.clicked[bool].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(x.toString()),
QKeySequence.keyBindings(QKeySequence.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(self.search.toolTip())))
self.advanced_search_button.setStatusTip(
self.advanced_search_button.toolTip())
self.clear_button.setStatusTip(self.clear_button.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)
def __init__(self,
pathtoebook=None,
debug_javascript=False,
open_at=None,
start_in_fullscreen=False):
MainWindow.__init__(self, None)
self.setupUi(self)
self.view.initialize_view(debug_javascript)
self.view.magnification_changed.connect(self.magnification_changed)
self.show_toc_on_open = False
self.current_book_has_toc = False
self.base_window_title = unicode(self.windowTitle())
self.iterator = None
self.current_page = None
self.pending_search = None
self.pending_search_dir = None
self.pending_anchor = None
self.pending_reference = None
self.pending_bookmark = None
self.pending_restore = False
self.existing_bookmarks = []
self.selected_text = None
self.was_maximized = False
self.read_settings()
self.dictionary_box.hide()
self.close_dictionary_view.clicked.connect(
lambda x: self.dictionary_box.hide())
self.history = History(self.action_back, self.action_forward)
self.metadata = Metadata(self)
self.pos = DoubleSpinBox()
self.pos.setDecimals(1)
self.pos.setSuffix('/' + _('Unknown') + ' ')
self.pos.setMinimum(1.)
self.pos.value_changed.connect(self.update_pos_label)
self.splitter.setCollapsible(0, False)
self.splitter.setCollapsible(1, False)
self.pos.setMinimumWidth(150)
self.tool_bar2.insertWidget(self.action_find_next, self.pos)
self.reference = Reference()
self.tool_bar2.insertSeparator(self.action_find_next)
self.tool_bar2.insertWidget(self.action_find_next, self.reference)
self.tool_bar2.insertSeparator(self.action_find_next)
self.setFocusPolicy(Qt.StrongFocus)
self.search = SearchBox2(self)
self.search.setMinimumContentsLength(20)
self.search.initialize('viewer_search_history')
self.search.setToolTip(_('Search for text in book'))
self.search.setMinimumWidth(200)
self.tool_bar2.insertWidget(self.action_find_next, self.search)
self.view.set_manager(self)
self.pi = ProgressIndicator(self)
self.toc.setVisible(False)
self.action_quit = QAction(_('&Quit'), self)
self.addAction(self.action_quit)
self.view_resized_timer = QTimer(self)
self.view_resized_timer.timeout.connect(self.viewport_resize_finished)
self.view_resized_timer.setSingleShot(True)
self.resize_in_progress = False
qs = [Qt.CTRL + Qt.Key_Q, Qt.CTRL + Qt.Key_W]
self.action_quit.setShortcuts(qs)
self.action_quit.triggered.connect(self.quit)
self.action_focus_search = QAction(self)
self.addAction(self.action_focus_search)
self.action_focus_search.setShortcuts(
[Qt.Key_Slash, QKeySequence(QKeySequence.Find)])
self.action_focus_search.triggered.connect(
lambda x: self.search.setFocus(Qt.OtherFocusReason))
self.action_copy.setDisabled(True)
self.action_metadata.setCheckable(True)
self.action_metadata.setShortcut(Qt.CTRL + Qt.Key_I)
self.action_table_of_contents.setCheckable(True)
self.toc.setMinimumWidth(80)
self.action_reference_mode.setCheckable(True)
self.action_reference_mode.triggered[bool].connect(
self.view.reference_mode)
self.action_metadata.triggered[bool].connect(self.metadata.setVisible)
self.action_table_of_contents.toggled[bool].connect(
self.set_toc_visible)
self.action_copy.triggered[bool].connect(self.copy)
self.action_font_size_larger.triggered.connect(self.font_size_larger)
self.action_font_size_smaller.triggered.connect(self.font_size_smaller)
self.action_font_size_larger.setShortcut(Qt.CTRL + Qt.Key_Equal)
self.action_font_size_smaller.setShortcut(Qt.CTRL + Qt.Key_Minus)
self.action_open_ebook.triggered[bool].connect(self.open_ebook)
self.action_next_page.triggered.connect(self.view.next_page)
self.action_previous_page.triggered.connect(self.view.previous_page)
self.action_find_next.triggered.connect(self.find_next)
self.action_find_previous.triggered.connect(self.find_previous)
self.action_full_screen.triggered[bool].connect(self.toggle_fullscreen)
self.action_full_screen.setShortcuts(
[Qt.Key_F11, Qt.CTRL + Qt.SHIFT + Qt.Key_F])
self.action_full_screen.setToolTip(
_('Toggle full screen (%s)') % _(' or ').join([
unicode(x.toString(x.NativeText))
for x in self.action_full_screen.shortcuts()
]))
self.action_back.triggered[bool].connect(self.back)
self.action_forward.triggered[bool].connect(self.forward)
self.action_bookmark.triggered[bool].connect(self.bookmark)
self.action_preferences.triggered.connect(self.do_config)
self.pos.editingFinished.connect(self.goto_page_num)
self.vertical_scrollbar.valueChanged[int].connect(
lambda x: self.goto_page(x / 100.))
self.search.search.connect(self.find)
self.search.focus_to_library.connect(
lambda: self.view.setFocus(Qt.OtherFocusReason))
self.toc.pressed[QModelIndex].connect(self.toc_clicked)
self.reference.goto.connect(self.goto)
self.bookmarks_menu = QMenu()
self.action_bookmark.setMenu(self.bookmarks_menu)
self.set_bookmarks([])
self.themes_menu = QMenu()
self.action_load_theme.setMenu(self.themes_menu)
self.tool_bar.widgetForAction(self.action_load_theme).setPopupMode(
QToolButton.InstantPopup)
self.load_theme_menu()
if pathtoebook is not None:
f = functools.partial(self.load_ebook,
pathtoebook,
open_at=open_at)
QTimer.singleShot(50, f)
self.view.setMinimumSize(100, 100)
self.toc.setCursor(Qt.PointingHandCursor)
self.tool_bar.setContextMenuPolicy(Qt.PreventContextMenu)
self.tool_bar2.setContextMenuPolicy(Qt.PreventContextMenu)
self.tool_bar.widgetForAction(self.action_bookmark).setPopupMode(
QToolButton.MenuButtonPopup)
self.action_full_screen.setCheckable(True)
self.full_screen_label = QLabel(
'''
<center>
<h1>%s</h1>
<h3>%s</h3>
<h3>%s</h3>
<h3>%s</h3>
</center>
''' %
(_('Full screen mode'), _('Right click to show controls'),
_('Tap in the left or right page margin to turn pages'),
_('Press Esc to quit')), self)
self.full_screen_label.setVisible(False)
self.full_screen_label.setStyleSheet('''
QLabel {
text-align: center;
background-color: white;
color: black;
border-width: 1px;
border-style: solid;
border-radius: 20px;
}
''')
self.window_mode_changed = None
self.toggle_toolbar_action = QAction(_('Show/hide controls'), self)
self.toggle_toolbar_action.setCheckable(True)
self.toggle_toolbar_action.triggered.connect(self.toggle_toolbars)
self.toolbar_hidden = None
self.addAction(self.toggle_toolbar_action)
self.full_screen_label_anim = QPropertyAnimation(
self.full_screen_label, 'size')
self.clock_label = QLabel('99:99', self)
self.clock_label.setVisible(False)
self.clock_label.setFocusPolicy(Qt.NoFocus)
self.info_label_style = '''
QLabel {
text-align: center;
border-width: 1px;
border-style: solid;
border-radius: 8px;
background-color: %s;
color: %s;
font-family: monospace;
font-size: larger;
padding: 5px;
}'''
self.original_frame_style = self.frame.frameStyle()
self.pos_label = QLabel('2000/4000', self)
self.pos_label.setVisible(False)
self.pos_label.setFocusPolicy(Qt.NoFocus)
self.clock_timer = QTimer(self)
self.clock_timer.timeout.connect(self.update_clock)
self.esc_full_screen_action = a = QAction(self)
self.addAction(a)
a.setShortcut(Qt.Key_Escape)
a.setEnabled(False)
a.triggered.connect(self.action_full_screen.trigger)
self.print_menu = QMenu()
self.print_menu.addAction(QIcon(I('print-preview.png')),
_('Print Preview'))
self.action_print.setMenu(self.print_menu)
self.tool_bar.widgetForAction(self.action_print).setPopupMode(
QToolButton.MenuButtonPopup)
self.action_print.triggered.connect(self.print_book)
self.print_menu.actions()[0].triggered.connect(self.print_preview)
ca = self.view.copy_action
ca.setShortcut(QKeySequence.Copy)
self.addAction(ca)
self.open_history_menu = QMenu()
self.clear_recent_history_action = QAction(
_('Clear list of recently opened books'), self)
self.clear_recent_history_action.triggered.connect(
self.clear_recent_history)
self.build_recent_menu()
self.action_open_ebook.setMenu(self.open_history_menu)
self.open_history_menu.triggered[QAction].connect(self.open_recent)
w = self.tool_bar.widgetForAction(self.action_open_ebook)
w.setPopupMode(QToolButton.MenuButtonPopup)
for x in ('tool_bar', 'tool_bar2'):
x = getattr(self, x)
for action in x.actions():
# So that the keyboard shortcuts for these actions will
# continue to function even when the toolbars are hidden
self.addAction(action)
self.view.document.settings_changed.connect(self.settings_changed)
self.restore_state()
self.settings_changed()
self.action_toggle_paged_mode.toggled[bool].connect(
self.toggle_paged_mode)
if (start_in_fullscreen or self.view.document.start_in_fullscreen):
self.action_full_screen.trigger()
def __init__(self, parent, view, row, link_delegate):
QDialog.__init__(self, parent)
self.normal_brush = QBrush(Qt.white)
self.marked_brush = QBrush(Qt.lightGray)
self.marked = None
self.gui = parent
self.splitter = QSplitter(self)
self._l = l = QVBoxLayout(self)
self.setLayout(l)
l.addWidget(self.splitter)
self.cover = CoverView(self)
self.cover.resizeEvent = self.cover_view_resized
self.cover.cover_changed.connect(self.cover_changed)
self.cover_pixmap = None
self.cover.sizeHint = self.details_size_hint
self.splitter.addWidget(self.cover)
self.details = QWebView(self)
self.details.sizeHint = self.details_size_hint
self.details.page().setLinkDelegationPolicy(
self.details.page().DelegateAllLinks)
self.details.linkClicked.connect(self.link_clicked)
self.css = css()
self.link_delegate = link_delegate
self.details.setAttribute(Qt.WA_OpaquePaintEvent, False)
palette = self.details.palette()
self.details.setAcceptDrops(False)
palette.setBrush(QPalette.Base, Qt.transparent)
self.details.page().setPalette(palette)
self.c = QWidget(self)
self.c.l = l2 = QGridLayout(self.c)
self.c.setLayout(l2)
l2.addWidget(self.details, 0, 0, 1, -1)
self.splitter.addWidget(self.c)
self.fit_cover = QCheckBox(_('Fit &cover within view'), self)
self.fit_cover.setChecked(
gprefs.get('book_info_dialog_fit_cover', True))
l2.addWidget(self.fit_cover, l2.rowCount(), 0, 1, -1)
self.previous_button = QPushButton(QIcon(I('previous.png')),
_('&Previous'), self)
self.previous_button.clicked.connect(self.previous)
l2.addWidget(self.previous_button, l2.rowCount(), 0)
self.next_button = QPushButton(QIcon(I('next.png')), _('&Next'), self)
self.next_button.clicked.connect(self.next)
l2.addWidget(self.next_button, l2.rowCount() - 1, 1)
self.view = view
self.current_row = None
self.refresh(row)
self.view.selectionModel().currentChanged.connect(self.slave)
self.fit_cover.stateChanged.connect(self.toggle_cover_fit)
self.ns = QShortcut(QKeySequence('Alt+Right'), self)
self.ns.activated.connect(self.next)
self.ps = QShortcut(QKeySequence('Alt+Left'), self)
self.ps.activated.connect(self.previous)
self.next_button.setToolTip(
_('Next [%s]') %
unicode(self.ns.key().toString(QKeySequence.NativeText)))
self.previous_button.setToolTip(
_('Previous [%s]') %
unicode(self.ps.key().toString(QKeySequence.NativeText)))
geom = QCoreApplication.instance().desktop().availableGeometry(self)
screen_height = geom.height() - 100
screen_width = geom.width() - 100
self.resize(max(int(screen_width / 2), 700), screen_height)
saved_layout = gprefs.get('book_info_dialog_layout', None)
if saved_layout is not None:
try:
self.restoreGeometry(saved_layout[0])
self.splitter.restoreState(saved_layout[1])
except Exception:
pass
class Runner:
_window = None
_application = None
def __init__(self):
self._application = QApplication(sys.argv)
self._window = None
# Main Window Initialized..
try:
self._window = yali.gui.YaliWindow.Widget()
except yali.Error, msg:
ctx.logger.debug(msg)
sys.exit(1)
self._translator = QTranslator()
self._translator.load(
"qt_" + QLocale.system().name(),
QLibraryInfo.location(QLibraryInfo.TranslationsPath))
ctx.mainScreen = self._window
screens = self._get_screens(ctx.flags.install_type)
self._set_steps(screens)
# These shorcuts for developers :)
prevScreenShortCut = QShortcut(QKeySequence(Qt.SHIFT + Qt.Key_F1),
self._window)
nextScreenShortCut = QShortcut(QKeySequence(Qt.SHIFT + Qt.Key_F2),
self._window)
QObject.connect(prevScreenShortCut, SIGNAL("activated()"),
self._window.slotBack)
QObject.connect(nextScreenShortCut, SIGNAL("activated()"),
self._window.slotNext)
# VBox utils
ctx.logger.debug("Starting VirtualBox tools..")
#FIXME:sh /etc/X11/Xsession.d/98-vboxclient.sh
yali.util.run_batch("VBoxClient", ["--autoresize"])
yali.util.run_batch("VBoxClient", ["--clipboard"])
# Cp Reboot, ShutDown
yali.util.run_batch("cp", ["/sbin/reboot", "/tmp/reboot"])
yali.util.run_batch("cp", ["/sbin/shutdown", "/tmp/shutdown"])
# base connections
QObject.connect(self._application, SIGNAL("lastWindowClosed()"),
self._application, SLOT("quit()"))
QObject.connect(self._window, SIGNAL("signalProcessEvents"),
self._application.processEvents)
QObject.connect(self._application.desktop(), SIGNAL("resized(int)"),
self._reinit_screen)
# Font Resize
fontMinusShortCut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_Minus),
self._window)
fontPlusShortCut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_Plus),
self._window)
QObject.connect(fontMinusShortCut, SIGNAL("activated()"),
self._window.setFontMinus)
QObject.connect(fontPlusShortCut, SIGNAL("activated()"),
self._window.setFontPlus)
def __init__(self, gui, initial_plugin=None, close_after_initial=False):
QMainWindow.__init__(self, gui)
self.gui = gui
self.must_restart = False
self.committed = False
self.close_after_initial = close_after_initial
self.resize(930, 720)
nh, nw = min_available_height()-25, available_width()-10
if nh < 0:
nh = 800
if nw < 0:
nw = 600
nh = min(self.height(), nh)
nw = min(self.width(), nw)
self.resize(nw, nh)
self.esc_action = QAction(self)
self.addAction(self.esc_action)
self.esc_action.setShortcut(QKeySequence(Qt.Key_Escape))
self.esc_action.triggered.connect(self.esc)
geom = gprefs.get('preferences_window_geometry', None)
if geom is not None:
self.restoreGeometry(geom)
# Center
if islinux:
self.move(gui.rect().center() - self.rect().center())
self.setWindowModality(Qt.WindowModal)
self.setWindowTitle(__appname__ + ' - ' + _('Preferences'))
self.setWindowIcon(QIcon(I('config.png')))
self.status_bar = StatusBar(self)
self.setStatusBar(self.status_bar)
self.stack = QStackedWidget(self)
self.cw = QWidget(self)
self.cw.setLayout(QVBoxLayout())
self.cw.layout().addWidget(self.stack)
self.bb = QDialogButtonBox(QDialogButtonBox.Close)
self.wizard_button = self.bb.addButton(_('Run welcome wizard'),
self.bb.ActionRole)
self.wizard_button.setIcon(QIcon(I('wizard.png')))
self.wizard_button.clicked.connect(self.run_wizard,
type=Qt.QueuedConnection)
self.cw.layout().addWidget(self.bb)
self.bb.button(self.bb.Close).setDefault(True)
self.bb.rejected.connect(self.close, type=Qt.QueuedConnection)
self.setCentralWidget(self.cw)
self.browser = Browser(self)
self.browser.show_plugin.connect(self.show_plugin)
self.stack.addWidget(self.browser)
self.scroll_area = QScrollArea(self)
self.stack.addWidget(self.scroll_area)
self.scroll_area.setWidgetResizable(True)
self.bar = QToolBar(self)
self.addToolBar(self.bar)
self.bar.setVisible(False)
self.bar.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
self.bar.setMovable(False)
self.bar.setFloatable(False)
self.bar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.apply_action = self.bar.addAction(QIcon(I('ok.png')), _('&Apply'),
self.commit)
self.cancel_action = self.bar.addAction(QIcon(I('window-close.png')),
_('&Cancel'), self.cancel)
self.bar_title = BarTitle(self.bar)
self.bar.addWidget(self.bar_title)
self.restore_action = self.bar.addAction(QIcon(I('clear_left.png')),
_('Restore &defaults'), self.restore_defaults)
for ac, tt in [('apply', _('Save changes')),
('cancel', _('Cancel and return to overview'))]:
ac = getattr(self, ac+'_action')
ac.setToolTip(tt)
ac.setWhatsThis(tt)
ac.setStatusTip(tt)
for ch in self.bar.children():
if isinstance(ch, QToolButton):
ch.setCursor(Qt.PointingHandCursor)
ch.setAutoRaise(True)
self.stack.setCurrentIndex(0)
if initial_plugin is not None:
category, name = initial_plugin
plugin = get_plugin(category, name)
if plugin is not None:
self.show_plugin(plugin)
def __init__(self, parent=None):
QWebView.__init__(self, parent)
self.comments_pat = re.compile(r'<!--.*?-->', re.DOTALL)
extra_shortcuts = {
'ToggleBold': 'Bold',
'ToggleItalic': 'Italic',
'ToggleUnderline': 'Underline',
}
for wac, name, icon, text, checkable in [
('ToggleBold', 'bold', 'format-text-bold', _('Bold'), True),
('ToggleItalic', 'italic', 'format-text-italic', _('Italic'),
True),
('ToggleUnderline', 'underline', 'format-text-underline',
_('Underline'), True),
('ToggleStrikethrough', 'strikethrough',
'format-text-strikethrough', _('Strikethrough'), True),
('ToggleSuperscript', 'superscript', 'format-text-superscript',
_('Superscript'), True),
('ToggleSubscript', 'subscript', 'format-text-subscript',
_('Subscript'), True),
('InsertOrderedList', 'ordered_list', 'format-list-ordered',
_('Ordered list'), True),
('InsertUnorderedList', 'unordered_list', 'format-list-unordered',
_('Unordered list'), True),
('AlignLeft', 'align_left', 'format-justify-left', _('Align left'),
False),
('AlignCenter', 'align_center', 'format-justify-center',
_('Align center'), False),
('AlignRight', 'align_right', 'format-justify-right',
_('Align right'), False),
('AlignJustified', 'align_justified', 'format-justify-fill',
_('Align justified'), False),
('Undo', 'undo', 'edit-undo', _('Undo'), False),
('Redo', 'redo', 'edit-redo', _('Redo'), False),
('RemoveFormat', 'remove_format', 'trash', _('Remove formatting'),
False),
('Copy', 'copy', 'edit-copy', _('Copy'), False),
('Paste', 'paste', 'edit-paste', _('Paste'), False),
('Cut', 'cut', 'edit-cut', _('Cut'), False),
('Indent', 'indent', 'format-indent-more',
_('Increase Indentation'), False),
('Outdent', 'outdent', 'format-indent-less',
_('Decrease Indentation'), False),
('SelectAll', 'select_all', 'edit-select-all', _('Select all'),
False),
]:
ac = PageAction(wac, icon, text, checkable, self)
setattr(self, 'action_' + name, ac)
ss = extra_shortcuts.get(wac, None)
if ss:
ac.setShortcut(QKeySequence(getattr(QKeySequence, ss)))
if wac == 'RemoveFormat':
ac.triggered.connect(self.remove_format_cleanup,
type=Qt.QueuedConnection)
self.action_color = QAction(QIcon(I('format-text-color')),
_('Foreground color'), self)
self.action_color.triggered.connect(self.foreground_color)
self.action_background = QAction(QIcon(I('format-fill-color')),
_('Background color'), self)
self.action_background.triggered.connect(self.background_color)
self.action_block_style = QAction(QIcon(I('format-text-heading')),
_('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 = []
for text, name in [
(_('Normal'), 'p'),
(_('Heading') + ' 1', 'h1'),
(_('Heading') + ' 2', 'h2'),
(_('Heading') + ' 3', 'h3'),
(_('Heading') + ' 4', 'h4'),
(_('Heading') + ' 5', 'h5'),
(_('Heading') + ' 6', 'h6'),
(_('Pre-formatted'), 'pre'),
(_('Blockquote'), 'blockquote'),
(_('Address'), 'address'),
]:
ac = BlockStyleAction(text, name, self)
self.block_style_menu.addAction(ac)
self.block_style_actions.append(ac)
self.action_insert_link = QAction(QIcon(I('insert-link.png')),
_('Insert link'), self)
self.action_insert_link.triggered.connect(self.insert_link)
self.action_clear = QAction(QIcon(I('edit-clear')), _('Clear'), self)
self.action_clear.triggered.connect(self.clear_text)
self.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.page().linkClicked.connect(self.link_clicked)
self.setHtml('')
self.page().setContentEditable(True)
def genesis(self, gui):
self.gui = gui
db = gui.library_view.model().db
r = self.register
r('gui_layout', config, restart_required=True, choices=[(_('Wide'), 'wide'), (_('Narrow'), 'narrow')])
r('ui_style', gprefs, restart_required=True, choices=[(_('System default'), 'system'), (_('Calibre style'),
'calibre')])
r('book_list_tooltips', gprefs)
r('tag_browser_old_look', gprefs, restart_required=True)
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', gprefs)
r('cover_grid_disk_cache_size', gprefs)
r('cover_grid_spacing', gprefs)
r('cover_grid_show_title', gprefs)
r('cover_flow_queue_length', config, restart_required=True)
r('cover_browser_reflections', gprefs)
r('show_rating_in_cover_browser', gprefs)
r('extra_row_spacing', gprefs)
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(cmp=lambda x, y: cmp(x[1].lower(), y[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)
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('default_author_link', gprefs)
r('tag_browser_dont_collapse', gprefs, setting=CommaSeparatedList)
choices = set([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 -= set(['authors', 'publisher', 'formats', 'news', 'identifiers'])
choices |= set(['search'])
self.opt_categories_using_hierarchy.update_items_cache(choices)
r('categories_using_hierarchy', db.prefs, setting=CommaSeparatedList,
choices=sorted(list(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)
self.df_up_button.clicked.connect(self.move_df_up)
self.df_down_button.clicked.connect(self.move_df_down)
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.tabWidget.setCurrentIndex(0)
keys = [QKeySequence('F11', QKeySequence.PortableText), QKeySequence(
'Ctrl+Shift+F', QKeySequence.PortableText)]
keys = [unicode(x.toString(QKeySequence.NativeText)) for x in keys]
self.fs_help_msg.setText(unicode(self.fs_help_msg.text())%(
_(' or ').join(keys)))
self.size_calculated.connect(self.update_cg_cache_size, type=Qt.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.Fixed, QSizePolicy.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.Fixed, QSizePolicy.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.Fixed, QSizePolicy.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)
self.cover_grid_smaller_cover.clicked.connect(partial(self.resize_cover, True))
self.cover_grid_larger_cover.clicked.connect(partial(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)
def __init__(self, parent):
QWidget.__init__(self, parent)
self.parent = parent
self._layout = QVBoxLayout()
self.setLayout(self._layout)
self._layout.setContentsMargins(0,0,0,0)
# Set up the find box & button
search_layout = QHBoxLayout()
self._layout.addLayout(search_layout)
self.item_search = HistoryLineEdit(parent)
self.item_search.setMinimumContentsLength(5)
self.item_search.setSizeAdjustPolicy(self.item_search.AdjustToMinimumContentsLengthWithIcon)
try:
self.item_search.lineEdit().setPlaceholderText(
_('Find item in tag browser'))
except:
pass # Using Qt < 4.7
self.item_search.setToolTip(_(
'Search for items. This is a "contains" search; items containing the\n'
'text anywhere in the name will be found. You can limit the search\n'
'to particular categories using syntax similar to search. For example,\n'
'tags:foo will find foo in any tag, but not in authors etc. Entering\n'
'*foo will filter all categories at once, showing only those items\n'
'containing the text "foo"'))
search_layout.addWidget(self.item_search)
# Not sure if the shortcut should be translatable ...
sc = QShortcut(QKeySequence(_('ALT+f')), parent)
sc.activated.connect(self.set_focus_to_find_box)
self.search_button = QToolButton()
self.search_button.setText(_('F&ind'))
self.search_button.setToolTip(_('Find the first/next matching item'))
search_layout.addWidget(self.search_button)
self.expand_button = QToolButton()
self.expand_button.setText('-')
self.expand_button.setToolTip(_('Collapse all categories'))
search_layout.addWidget(self.expand_button)
search_layout.setStretch(0, 10)
search_layout.setStretch(1, 1)
search_layout.setStretch(2, 1)
self.current_find_position = None
self.search_button.clicked.connect(self.find)
self.item_search.initialize('tag_browser_search')
self.item_search.lineEdit().returnPressed.connect(self.do_find)
self.item_search.lineEdit().textEdited.connect(self.find_text_changed)
self.item_search.activated[QString].connect(self.do_find)
self.item_search.completer().setCaseSensitivity(Qt.CaseSensitive)
parent.tags_view = TagsView(parent)
self.tags_view = parent.tags_view
self.expand_button.clicked.connect(self.tags_view.collapseAll)
self._layout.addWidget(parent.tags_view)
# Now the floating 'not found' box
l = QLabel(self.tags_view)
self.not_found_label = l
l.setFrameStyle(QFrame.StyledPanel)
l.setAutoFillBackground(True)
l.setText('<p><b>'+_('No More Matches.</b><p> Click Find again to go to first match'))
l.setAlignment(Qt.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.QueuedConnection)
parent.alter_tb = l = QPushButton(parent)
l.setText(_('Alter Tag Browser'))
l.setIcon(QIcon(I('tags.png')))
l.m = QMenu()
l.setMenu(l.m)
self._layout.addWidget(l)
sb = l.m.addAction(_('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((_('Sort by name'), _('Sort by number of books'),
_('Sort by 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(_('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)
def genesis(self, gui):
self.gui = gui
db = gui.library_view.model().db
r = self.register
r('gui_layout',
config,
restart_required=True,
choices=[(_('Wide'), 'wide'), (_('Narrow'), 'narrow')])
r('ui_style',
gprefs,
restart_required=True,
choices=[(_('System default'), 'system'),
(_('Calibre style'), 'calibre')])
r('book_list_tooltips', gprefs)
r('tag_browser_old_look', gprefs, restart_required=True)
r('cover_flow_queue_length', config, restart_required=True)
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(cmp=lambda x, y: cmp(x[1].lower(), y[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)
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('default_author_link', gprefs)
r('tag_browser_dont_collapse', gprefs, setting=CommaSeparatedList)
choices = set([
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 -= set(
['authors', 'publisher', 'formats', 'news', 'identifiers'])
choices |= set(['search'])
self.opt_categories_using_hierarchy.update_items_cache(choices)
r('categories_using_hierarchy',
db.prefs,
setting=CommaSeparatedList,
choices=sorted(list(choices), key=sort_key))
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)
self.df_up_button.clicked.connect(self.move_df_up)
self.df_down_button.clicked.connect(self.move_df_down)
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.tabWidget.setCurrentIndex(0)
keys = [
QKeySequence('F11', QKeySequence.PortableText),
QKeySequence('Ctrl+Shift+F', QKeySequence.PortableText)
]
keys = [unicode(x.toString(QKeySequence.NativeText)) for x in keys]
self.fs_help_msg.setText(
unicode(self.fs_help_msg.text()) % (_(' or ').join(keys)))
def key(k):
sc = unicode(
QKeySequence(k | Qt.CTRL).toString(QKeySequence.NativeText))
return ' [%s]' % sc
