def contextMenuEvent(self, ev):
from calibre.gui2.open_with import populate_menu, edit_programs
cm = QMenu(self)
paste = cm.addAction(_('Paste cover'))
copy = cm.addAction(_('Copy cover'))
save = cm.addAction(_('Save cover to disk'))
remove = cm.addAction(_('Remove cover'))
gc = cm.addAction(_('Generate cover from metadata'))
cm.addSeparator()
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
remove.triggered.connect(self.remove_cover)
gc.triggered.connect(self.generate_cover)
save.triggered.connect(self.save_cover)
m = QMenu(_('Open cover with...'))
def connect_action(ac, entry):
connect_lambda(ac.triggered, self, lambda self: self.open_with(entry))
populate_menu(m, connect_action, 'cover_image')
if len(m.actions()) == 0:
cm.addAction(_('Open cover with...'), self.choose_open_with)
else:
m.addSeparator()
m.addAction(_('Add another application to open cover...'), self.choose_open_with)
m.addAction(_('Edit Open with applications...'), partial(edit_programs, 'cover_image', self))
cm.ocw = m
cm.addMenu(m)
cm.si = m = create_search_internet_menu(self.search_internet.emit)
cm.addMenu(m)
cm.exec_(ev.globalPos())
def clone_changed(self):
otext = self.text()
self.setText(self.clone.text())
if otext != self.text:
self.text_changed.emit()
ov = self.isVisible()
self.setVisible(self.clone.isVisible())
if ov != self.isVisible():
self.visibility_changed.emit()
self.setEnabled(self.clone.isEnabled())
self.setCheckable(self.clone.isCheckable())
self.setChecked(self.clone.isChecked())
self.setIcon(self.clone.icon())
if self.clone_shortcuts:
self.setShortcuts(self.clone.shortcuts())
if self.clone.menu() is None:
if not self.is_top_level:
self.setMenu(None)
else:
m = QMenu(self.text(), self.parent())
for ac in QMenu.actions(self.clone.menu()):
if ac.isSeparator():
m.addSeparator()
else:
m.addAction(
CloneAction(ac,
self.parent(),
clone_shortcuts=self.clone_shortcuts))
self.setMenu(m)
def show_context_menu(self, point):
item = self.currentItem()
def key(k):
sc = unicode_type(QKeySequence(k | Qt.CTRL).toString(QKeySequence.NativeText))
return ' [%s]'%sc
if item is not None:
m = QMenu()
m.addAction(QIcon(I('edit_input.png')), _('Change the location this entry points to'), self.edit_item)
m.addAction(QIcon(I('modified.png')), _('Bulk rename all selected items'), self.bulk_rename)
m.addAction(QIcon(I('trash.png')), _('Remove all selected items'), self.del_items)
m.addSeparator()
ci = unicode_type(item.data(0, Qt.DisplayRole) or '')
p = item.parent() or self.invisibleRootItem()
idx = p.indexOfChild(item)
if idx > 0:
m.addAction(QIcon(I('arrow-up.png')), (_('Move "%s" up')%ci)+key(Qt.Key_Up), self.move_up)
if idx + 1 < p.childCount():
m.addAction(QIcon(I('arrow-down.png')), (_('Move "%s" down')%ci)+key(Qt.Key_Down), self.move_down)
if item.parent() is not None:
m.addAction(QIcon(I('back.png')), (_('Unindent "%s"')%ci)+key(Qt.Key_Left), self.move_left)
if idx > 0:
m.addAction(QIcon(I('forward.png')), (_('Indent "%s"')%ci)+key(Qt.Key_Right), self.move_right)
m.addSeparator()
case_menu = QMenu(_('Change case'))
case_menu.addAction(_('Upper case'), self.upper_case)
case_menu.addAction(_('Lower case'), self.lower_case)
case_menu.addAction(_('Swap case'), self.swap_case)
case_menu.addAction(_('Title case'), self.title_case)
case_menu.addAction(_('Capitalize'), self.capitalize)
m.addMenu(case_menu)
m.exec_(QCursor.pos())
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(_('Sort tabs alphabetically'), self.sort_alphabetically)
hidden = self.current_db.prefs['virt_libs_hidden']
if hidden:
s = m._s = m.addMenu(_('Restore hidden tabs'))
for x in hidden:
s.addAction(x, partial(self.restore, x))
m.addAction(_('Hide virtual library tabs'), self.disable_bar)
if gprefs['vl_tabs_closable']:
m.addAction(_('Lock virtual library tabs'), self.lock_tab)
else:
m.addAction(_('Unlock virtual library tabs'), self.unlock_tab)
i = self.tabAt(ev.pos())
if i > -1:
vl = unicode(self.tabData(i) or '')
if vl:
m.addSeparator()
m.addAction(
_('Edit "%s"') % vl,
partial(self.gui.do_create_edit, name=vl))
m.addAction(
_('Delete "%s"') % vl,
partial(self.gui.remove_vl_triggered, name=vl))
m.exec_(ev.globalPos())
def show_context_menu(self, pos):
item = self.itemAt(pos)
if item is not None:
result = item.data(0, Qt.ItemDataRole.UserRole)
else:
result = None
items = self.selectedItems()
m = QMenu(self)
if isinstance(result, dict):
m.addAction(_('Open in viewer'), partial(self.item_activated,
item))
m.addAction(_('Show in calibre'),
partial(self.show_in_calibre, item))
if result.get('annotation', {}).get('type') == 'highlight':
m.addAction(_('Edit notes'), partial(self.edit_notes, item))
if items:
m.addSeparator()
m.addAction(
ngettext('Export selected item', 'Export {} selected items',
len(items)).format(len(items)),
self.export_requested.emit)
m.addAction(
ngettext('Delete selected item', 'Delete {} selected items',
len(items)).format(len(items)),
self.delete_requested.emit)
m.addSeparator()
m.addAction(_('Expand all'), self.expandAll)
m.addAction(_('Collapse all'), self.collapseAll)
m.exec_(self.mapToGlobal(pos))
def create_action(self, for_toolbar=True):
self.plugin_prefs = JSONConfig(
'plugins/{0}_SpanDivEdit'.format(PLUGIN_SAFE_NAME))
self.plugin_prefs.defaults['parse_current'] = True
# Create an action, this will be added to the plugins toolbar and
# the plugins menu
ac = QAction(get_icons('images/spandivedit_icon.png'),
_('حذف تگ های اضافه'), self.gui)
self.restore_prefs()
if not for_toolbar:
# Register a keyboard shortcut for this toolbar action. We only
# register it for the action created for the menu, not the toolbar,
# to avoid a double trigger
self.register_shortcut(ac,
'edit-spans-divs',
default_keys=('Ctrl+Shift+Alt+E', ))
else:
menu = QMenu()
ac.setMenu(menu)
checked_menu_item = menu.addAction(_('Edit current file only'),
self.toggle_parse_current)
checked_menu_item.setCheckable(True)
checked_menu_item.setChecked(self.parse_current)
menu.addSeparator()
config_menu_item = menu.addAction(_('Customize'),
self.show_configuration)
ac.triggered.connect(self.dispatcher)
return ac
def contextMenuEvent(self, ev):
from calibre.gui2.open_with import populate_menu, edit_programs
cm = QMenu(self)
paste = cm.addAction(_("Paste Cover"))
copy = cm.addAction(_("Copy Cover"))
remove = cm.addAction(_("Remove Cover"))
gc = cm.addAction(_("Generate Cover from metadata"))
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
remove.triggered.connect(self.remove_cover)
gc.triggered.connect(self.generate_cover)
m = QMenu(_("Open cover with..."))
populate_menu(m, self.open_with, "cover_image")
if len(m.actions()) == 0:
cm.addAction(_("Open cover with..."), self.choose_open_with)
else:
m.addSeparator()
m.addAction(_("Add another application to open cover..."), self.choose_open_with)
m.addAction(_("Edit Open With applications..."), partial(edit_programs, "cover_image", self))
cm.addMenu(m)
cm.exec_(ev.globalPos())
def contextMenuEvent(self, ev):
from calibre.gui2.open_with import populate_menu, edit_programs
cm = QMenu(self)
paste = cm.addAction(_('Paste cover'))
copy = cm.addAction(_('Copy cover'))
remove = cm.addAction(_('Remove cover'))
gc = cm.addAction(_('Generate cover from metadata'))
cm.addSeparator()
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
remove.triggered.connect(self.remove_cover)
gc.triggered.connect(self.generate_cover)
m = QMenu(_('Open cover with...'))
populate_menu(m, self.open_with, 'cover_image')
if len(m.actions()) == 0:
cm.addAction(_('Open cover with...'), self.choose_open_with)
else:
m.addSeparator()
m.addAction(_('Add another application to open cover...'), self.choose_open_with)
m.addAction(_('Edit Open with applications...'), partial(edit_programs, 'cover_image', self))
cm.ocw = m
cm.addMenu(m)
cm.si = m = create_search_internet_menu(self.search_internet.emit)
cm.addMenu(m)
cm.exec_(ev.globalPos())
def show_context_menu(self, point):
item = self.currentItem()
def key(k):
sc = unicode_type(QKeySequence(k | Qt.CTRL).toString(QKeySequence.NativeText))
return ' [%s]'%sc
if item is not None:
m = QMenu()
m.addAction(QIcon(I('edit_input.png')), _('Change the location this entry points to'), self.edit_item)
m.addAction(QIcon(I('modified.png')), _('Bulk rename all selected items'), self.bulk_rename)
m.addAction(QIcon(I('trash.png')), _('Remove all selected items'), self.del_items)
m.addSeparator()
ci = unicode_type(item.data(0, Qt.DisplayRole) or '')
p = item.parent() or self.invisibleRootItem()
idx = p.indexOfChild(item)
if idx > 0:
m.addAction(QIcon(I('arrow-up.png')), (_('Move "%s" up')%ci)+key(Qt.Key_Up), self.move_up)
if idx + 1 < p.childCount():
m.addAction(QIcon(I('arrow-down.png')), (_('Move "%s" down')%ci)+key(Qt.Key_Down), self.move_down)
if item.parent() is not None:
m.addAction(QIcon(I('back.png')), (_('Unindent "%s"')%ci)+key(Qt.Key_Left), self.move_left)
if idx > 0:
m.addAction(QIcon(I('forward.png')), (_('Indent "%s"')%ci)+key(Qt.Key_Right), self.move_right)
m.addSeparator()
case_menu = QMenu(_('Change case'))
case_menu.addAction(_('Upper case'), self.upper_case)
case_menu.addAction(_('Lower case'), self.lower_case)
case_menu.addAction(_('Swap case'), self.swap_case)
case_menu.addAction(_('Title case'), self.title_case)
case_menu.addAction(_('Capitalize'), self.capitalize)
m.addMenu(case_menu)
m.exec_(QCursor.pos())
def setupEditActions(self):
tb = QToolBar(self)
tb.setWindowTitle("Edit Actions")
self.addToolBar(tb)
menu = QMenu("&Edit", self)
self.menuBar().addMenu(menu)
self.actionUndo = QAction("&Undo", self, shortcut=QKeySequence.Undo)
tb.addAction(self.actionUndo)
menu.addAction(self.actionUndo)
self.actionRedo = QAction("&Redo", self, priority=QAction.LowPriority, shortcut=QKeySequence.Redo)
tb.addAction(self.actionRedo)
menu.addAction(self.actionRedo)
menu.addSeparator()
self.actionCut = QAction("Cu&t", self, priority=QAction.LowPriority, shortcut=QKeySequence.Cut)
tb.addAction(self.actionCut)
menu.addAction(self.actionCut)
self.actionCopy = QAction("&Copy", self, priority=QAction.LowPriority, shortcut=QKeySequence.Copy)
tb.addAction(self.actionCopy)
menu.addAction(self.actionCopy)
self.actionPaste = QAction("&Paste", self, priority=QAction.LowPriority,
shortcut=QKeySequence.Paste, enabled=(len(QApplication.clipboard().text()) != 0))
tb.addAction(self.actionPaste)
menu.addAction(self.actionPaste)
def genesis(self):
md = self.qaction.menu()
cm = partial(self.create_menu_action, md)
cm('individual', _('Edit metadata individually'), icon=self.qaction.icon(),
triggered=partial(self.edit_metadata, False, bulk=False))
md.addSeparator()
cm('bulk', _('Edit metadata in bulk'),
triggered=partial(self.edit_metadata, False, bulk=True))
md.addSeparator()
cm('download', _('Download metadata and covers'),
triggered=partial(self.download_metadata, ids=None),
shortcut='Ctrl+D')
self.metadata_menu = md
mb = QMenu()
cm2 = partial(self.create_menu_action, mb)
cm2('merge delete', _('Merge into first selected book - delete others'),
triggered=self.merge_books)
mb.addSeparator()
cm2('merge keep', _('Merge into first selected book - keep others'),
triggered=partial(self.merge_books, safe_merge=True),
shortcut='Alt+M')
mb.addSeparator()
cm2('merge formats', _('Merge only formats into first selected book - delete others'),
triggered=partial(self.merge_books, merge_only_formats=True),
shortcut='Alt+Shift+M')
self.merge_menu = mb
md.addSeparator()
self.action_merge = cm('merge', _('Merge book records'), icon='merge_books.png',
shortcut=_('M'), triggered=self.merge_books)
self.action_merge.setMenu(mb)
self.qaction.triggered.connect(self.edit_metadata)
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(_('Set to undefined') + '\t' + QKeySequence(Qt.Key_Space).toString(QKeySequence.NativeText),
self.clear_to_undefined)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m)
m.popup(ev.globalPos())
def clone_changed(self):
otext = self.text()
self.setText(self.clone.text())
if otext != self.text:
self.text_changed.emit()
ov = self.isVisible()
self.setVisible(self.clone.isVisible())
if ov != self.isVisible():
self.visibility_changed.emit()
self.setEnabled(self.clone.isEnabled())
self.setCheckable(self.clone.isCheckable())
self.setChecked(self.clone.isChecked())
self.setIcon(self.clone.icon())
if self.clone_shortcuts:
self.setShortcuts(self.clone.shortcuts())
if self.clone.menu() is None:
if not self.is_top_level:
self.setMenu(None)
else:
m = QMenu(self.text(), self.parent())
for ac in QMenu.actions(self.clone.menu()):
if ac.isSeparator():
m.addSeparator()
else:
m.addAction(CloneAction(ac, self.parent(), clone_shortcuts=self.clone_shortcuts))
self.setMenu(m)
def setupFileActions(self):
tb = QToolBar(self)
tb.setWindowTitle("File Actions")
self.addToolBar(tb)
menu = QMenu("&File", self)
self.menuBar().addMenu(menu)
self.actionNew = QAction("&New", self, priority=QAction.LowPriority,
shortcut=QKeySequence.New, triggered=self.fileNew)
tb.addAction(self.actionNew)
menu.addAction(self.actionNew)
self.actionOpen = QAction("&Open...", self, shortcut=QKeySequence.Open,
triggered=self.fileOpen)
tb.addAction(self.actionOpen)
menu.addAction(self.actionOpen)
menu.addSeparator()
self.actionSave = QAction("&Save", self, shortcut=QKeySequence.Save,
triggered=self.fileSave, enabled=False)
tb.addAction(self.actionSave)
menu.addAction(self.actionSave)
self.actionSaveAs = QAction("Save &As...", self, priority=QAction.LowPriority,
shortcut=Qt.CTRL + Qt.SHIFT + Qt.Key_S, triggered=self.fileSaveAs)
menu.addAction(self.actionSaveAs)
menu.addSeparator()
self.actionQuit = QAction("&Quit", self, shortcut=QKeySequence.Quit, triggered=self.close)
menu.addAction(self.actionQuit)
def details_context_menu_event(view,
ev,
book_info,
add_popup_action=False,
edit_metadata=None):
url = view.anchorAt(ev.pos())
menu = QMenu(view)
copy_menu = menu.addMenu(QIcon(I('edit-copy.png')), _('Copy'))
copy_menu.addAction(QIcon(I('edit-copy.png')), _('All book details'),
partial(copy_all, view))
if view.textCursor().hasSelection():
copy_menu.addAction(QIcon(I('edit-copy.png')), _('Selected text'),
view.copy)
copy_menu.addSeparator()
copy_links_added = False
search_internet_added = False
search_menu = QMenu(_('Search'), menu)
search_menu.setIcon(QIcon(I('search.png')))
if url and url.startswith('action:'):
data = json_loads(from_hex_bytes(url.split(':', 1)[1]))
search_internet_added = add_item_specific_entries(
menu, data, book_info, copy_menu, search_menu)
create_copy_links(copy_menu, data)
copy_links_added = True
elif url and not url.startswith('#'):
ac = book_info.copy_link_action
ac.current_url = url
ac.setText(_('Copy link location'))
menu.addAction(ac)
if not copy_links_added:
create_copy_links(copy_menu)
if not search_internet_added and hasattr(book_info, 'search_internet'):
sim = create_search_internet_menu(book_info.search_internet)
if search_menu.isEmpty():
search_menu = sim
else:
search_menu.addSeparator()
for ac in sim.actions():
search_menu.addAction(ac)
ac.setText(_('Search {0} for this book').format(ac.text()))
if not search_menu.isEmpty():
menu.addMenu(search_menu)
for ac in tuple(menu.actions()):
if not ac.isEnabled():
menu.removeAction(ac)
menu.addSeparator()
if add_popup_action:
ac = menu.addAction(_('Open the Book details window'))
ac.triggered.connect(book_info.show_book_info)
else:
from calibre.gui2.ui import get_gui
ema = get_gui().iactions['Edit Metadata'].menuless_qaction
menu.addAction(
_('Open the Edit metadata window') + '\t' +
ema.shortcut().toString(QKeySequence.SequenceFormat.NativeText),
edit_metadata)
if len(menu.actions()) > 0:
menu.exec_(ev.globalPos())
def create_context_menu(self):
m = QMenu(self)
m.addAction(_('Set date to undefined') + '\t' + QKeySequence(Qt.Key_Minus).toString(QKeySequence.NativeText),
self.clear_date)
m.addAction(_('Set date to today') + '\t' + QKeySequence(Qt.Key_Equal).toString(QKeySequence.NativeText),
self.today_date)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m, use_self_for_copy_actions=True)
return m
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(
_('Set to undefined') + '\t' +
QKeySequence(Qt.Key_Space).toString(QKeySequence.NativeText),
self.clear_to_undefined)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m)
m.popup(ev.globalPos())
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(_('Set date to undefined') + '\t' + QKeySequence(Qt.Key_Minus).toString(QKeySequence.NativeText),
self.clear_date)
m.addAction(_('Set date to today') + '\t' + QKeySequence(Qt.Key_Equal).toString(QKeySequence.NativeText),
self.today_date)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m)
m.popup(ev.globalPos())
def context_menu(self, pos):
index = self.indexAt(pos)
m = QMenu(self)
if index.isValid():
m.addAction(_('Expand all items under %s') % index.data(), partial(self.expand_tree, index))
m.addSeparator()
m.addAction(_('Expand all items'), self.expandAll)
m.addAction(_('Collapse all items'), self.collapseAll)
m.exec_(self.mapToGlobal(pos))
def add_format_entries(menu, data, book_info):
from calibre.ebooks.oeb.polish.main import SUPPORTED
from calibre.gui2.ui import get_gui
book_id = int(data['book_id'])
fmt = data['fmt']
init_find_in_tag_browser(menu, book_info.find_in_tag_browser_action, 'formats', fmt)
db = get_gui().current_db.new_api
ofmt = fmt.upper() if fmt.startswith('ORIGINAL_') else 'ORIGINAL_' + fmt
nfmt = ofmt[len('ORIGINAL_'):]
fmts = {x.upper() for x in db.formats(book_id)}
for a, t in [
('remove', _('Delete the %s format')),
('save', _('Save the %s format to disk')),
('restore', _('Restore the %s format')),
('compare', ''),
('set_cover', _('Set the book cover from the %s file')),
]:
if a == 'restore' and not fmt.startswith('ORIGINAL_'):
continue
if a == 'compare':
if ofmt not in fmts or nfmt not in SUPPORTED:
continue
t = _('Compare to the %s format') % (fmt[9:] if fmt.startswith('ORIGINAL_') else ofmt)
else:
t = t % fmt
ac = getattr(book_info, '%s_format_action'%a)
ac.current_fmt = (book_id, fmt)
ac.setText(t)
menu.addAction(ac)
if not fmt.upper().startswith('ORIGINAL_'):
from calibre.gui2.open_with import populate_menu, edit_programs
m = QMenu(_('Open %s with...') % fmt.upper())
def connect_action(ac, entry):
connect_lambda(ac.triggered, book_info, lambda book_info: book_info.open_with(book_id, fmt, entry))
populate_menu(m, connect_action, fmt)
if len(m.actions()) == 0:
menu.addAction(_('Open %s with...') % fmt.upper(), partial(book_info.choose_open_with, book_id, fmt))
else:
m.addSeparator()
m.addAction(_('Add other application for %s files...') % fmt.upper(), partial(book_info.choose_open_with, book_id, fmt))
m.addAction(_('Edit Open with applications...'), partial(edit_programs, fmt, book_info))
menu.addMenu(m)
menu.ow = m
if fmt.upper() in SUPPORTED:
menu.addSeparator()
menu.addAction(_('Edit %s...') % fmt.upper(), partial(book_info.edit_fmt, book_id, fmt))
path = data['path']
if path:
if data.get('fname'):
path = os.path.join(path, data['fname'] + '.' + data['fmt'].lower())
ac = book_info.copy_link_action
ac.current_url = path
ac.setText(_('&Copy path to file'))
menu.addAction(ac)
def _showConceptContextMenu(self, pos):
global_position = self.concept_list.mapToGlobal(pos)
my_menu = QMenu()
my_menu.addAction(self.edit_concept_action)
my_menu.addAction(self.delete_сoncept_action)
my_menu.addAction(self.delete_subcategory_action)
my_menu.addSeparator()
my_menu.addAction(self.help_action)
my_menu.addAction(self.exit_action)
my_menu.exec(global_position)
def showConceptContextMenu(self, pos):
if not len(self.concept_list.selectedItems()) == 1:
return
global_position = self.concept_list.mapToGlobal(pos)
my_menu = QMenu()
my_menu.addAction(self.edit_concept_action)
my_menu.addAction(self.delete_сoncept_action)
my_menu.addAction(self.delete_subcategory_action)
my_menu.addSeparator()
my_menu.addAction(self.help_action)
my_menu.addAction(self.exit_action)
my_menu.exec(global_position)
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(
_('Set date to undefined') + '\t' +
QKeySequence(Qt.Key_Minus).toString(QKeySequence.NativeText),
self.clear_date)
m.addAction(
_('Set date to today') + '\t' +
QKeySequence(Qt.Key_Equal).toString(QKeySequence.NativeText),
self.today_date)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m)
m.popup(ev.globalPos())
def genesis(self):
md = self.qaction.menu()
cm = partial(self.create_menu_action, md)
cm('individual',
_('Edit metadata individually'),
icon=self.qaction.icon(),
triggered=partial(self.edit_metadata, False, bulk=False))
md.addSeparator()
cm('bulk',
_('Edit metadata in bulk'),
triggered=partial(self.edit_metadata, False, bulk=True))
md.addSeparator()
cm('download',
_('Download metadata and covers'),
triggered=partial(self.download_metadata, ids=None),
shortcut='Ctrl+D')
self.metadata_menu = md
mb = QMenu()
cm2 = partial(self.create_menu_action, mb)
cm2('merge delete',
_('Merge into first selected book - delete others'),
triggered=self.merge_books)
mb.addSeparator()
cm2('merge keep',
_('Merge into first selected book - keep others'),
triggered=partial(self.merge_books, safe_merge=True),
shortcut='Alt+M')
mb.addSeparator()
cm2('merge formats',
_('Merge only formats into first selected book - delete others'),
triggered=partial(self.merge_books, merge_only_formats=True),
shortcut='Alt+Shift+M')
self.merge_menu = mb
md.addSeparator()
self.action_copy = cm('copy',
_('Copy metadata'),
icon='edit-copy.png',
triggered=self.copy_metadata)
self.action_paset = cm('paste',
_('Paste metadata'),
icon='edit-paste.png',
triggered=self.paste_metadata)
self.action_merge = cm('merge',
_('Merge book records'),
icon='merge_books.png',
shortcut=_('M'),
triggered=self.merge_books)
self.action_merge.setMenu(mb)
self.qaction.triggered.connect(self.edit_metadata)
def populate_open_with(self):
from calibre.gui2.open_with import populate_menu, edit_programs
menu = self.own
menu.clear()
fmt = self._formats[self.formats.currentRow()]
m = QMenu(_('Open %s with...') % fmt.upper(), menu)
populate_menu(m, self.open_with, fmt)
if len(m.actions()) == 0:
menu.addAction(_('Open %s with...') % fmt.upper(), self.choose_open_with)
else:
m.addSeparator()
m.addAction(_('Add other application for %s files...') % fmt.upper(), self.choose_open_with)
m.addAction(_('Edit Open With applications...'), partial(edit_programs, fmt, self))
menu.addMenu(m)
def scrollbar_context_menu(self, x, y, frac):
m = QMenu(self)
amap = {}
def a(text, name):
m.addAction(text)
amap[text] = name
a(_('Scroll here'), 'here')
m.addSeparator()
a(_('Start of book'), 'start_of_book')
a(_('End of book'), 'end_of_book')
m.addSeparator()
a(_('Previous section'), 'previous_section')
a(_('Next section'), 'next_section')
m.addSeparator()
a(_('Start of current file'), 'start_of_file')
a(_('End of current file'), 'end_of_file')
m.addSeparator()
a(_('Hide this scrollbar'), 'toggle_scrollbar')
q = m.exec_(QCursor.pos())
if not q:
return
q = amap[q.text()]
if q == 'here':
self.web_view.goto_frac(frac)
else:
self.web_view.trigger_shortcut(q)
def contextMenuEvent(self, event):
index = self.indexAt(event.pos())
if not index.isValid():
return
result = self.model().get_result(index)
menu = QMenu()
da = menu.addAction(_('Download...'), partial(self.download_requested.emit, result))
if not result.downloads:
da.setEnabled(False)
menu.addSeparator()
menu.addAction(_('Goto in store...'), partial(self.open_requested.emit, result))
menu.exec_(event.globalPos())
def contextMenuEvent(self, event):
index = self.indexAt(event.pos())
if not index.isValid():
return
result = self.model().get_result(index)
menu = QMenu()
da = menu.addAction(_('Download...'), partial(self.download_requested.emit, result))
if not result.downloads:
da.setEnabled(False)
menu.addSeparator()
menu.addAction(_('Goto in store...'), partial(self.open_requested.emit, result))
menu.exec_(event.globalPos())
def show_context_menu(self, point):
item = self.itemAt(point)
if item is None or item in set(self.categories.itervalues()):
return
m = QMenu(self)
sel = self.selectedItems()
num = len(sel)
container = current_container()
ci = self.currentItem()
if ci is not None:
cn = unicode(ci.data(0, NAME_ROLE) or '')
mt = unicode(ci.data(0, MIME_ROLE) or '')
cat = unicode(ci.data(0, CATEGORY_ROLE) or '')
n = elided_text(cn.rpartition('/')[-1])
m.addAction(QIcon(I('save.png')), _('Export %s') % n, partial(self.export, cn))
if cn not in container.names_that_must_not_be_changed and cn not in container.names_that_must_not_be_removed and mt not in OEB_FONTS:
m.addAction(_('Replace %s with file...') % n, partial(self.replace, cn))
if num > 1:
m.addAction(QIcon(I('save.png')), _('Export all %d selected files') % num, self.export_selected)
m.addSeparator()
m.addAction(QIcon(I('modified.png')), _('&Rename %s') % n, self.edit_current_item)
if is_raster_image(mt):
m.addAction(QIcon(I('default_cover.png')), _('Mark %s as cover image') % n, partial(self.mark_as_cover, cn))
elif current_container().SUPPORTS_TITLEPAGES and mt in OEB_DOCS and cat == 'text':
m.addAction(QIcon(I('default_cover.png')), _('Mark %s as cover page') % n, partial(self.mark_as_titlepage, cn))
m.addSeparator()
if num > 0:
m.addSeparator()
if num > 1:
m.addAction(QIcon(I('modified.png')), _('&Bulk rename the selected files'), self.request_bulk_rename)
m.addAction(QIcon(I('modified.png')), _('Change the file extension for the selected files'), self.request_change_ext)
m.addAction(QIcon(I('trash.png')), ngettext(
'&Delete the selected file', '&Delete the {} selected files', num).format(num), self.request_delete)
m.addAction(QIcon(I('edit-copy.png')), ngettext(
'&Copy the selected file to another editor instance',
'&Copy the {} selected files to another editor instance', num).format(num), self.copy_selected_files)
m.addSeparator()
selected_map = defaultdict(list)
for item in sel:
selected_map[unicode(item.data(0, CATEGORY_ROLE) or '')].append(unicode(item.data(0, NAME_ROLE) or ''))
for items in selected_map.itervalues():
items.sort(key=self.index_of_name)
if selected_map['text']:
m.addAction(QIcon(I('format-text-color.png')), _('Link &stylesheets...'), partial(self.link_stylesheets, selected_map['text']))
if len(selected_map['text']) > 1:
m.addAction(QIcon(I('merge.png')), _('&Merge selected text files'), partial(self.start_merge, 'text', selected_map['text']))
if len(selected_map['styles']) > 1:
m.addAction(QIcon(I('merge.png')), _('&Merge selected style files'), partial(self.start_merge, 'styles', selected_map['styles']))
if len(list(m.actions())) > 0:
m.popup(self.mapToGlobal(point))
def create_open_cover_with_menu(self, parent_menu):
from calibre.gui2.open_with import populate_menu, edit_programs
m = QMenu(_('Open cover with...'))
def connect_action(ac, entry):
connect_lambda(ac.triggered, self, lambda self: self.open_with(entry))
populate_menu(m, connect_action, 'cover_image')
if len(m.actions()) == 0:
parent_menu.addAction(_('Open cover with...'), self.choose_open_with)
else:
m.addSeparator()
m.addAction(_('Add another application to open cover...'), self.choose_open_with)
m.addAction(_('Edit Open with applications...'), partial(edit_programs, 'cover_image', self))
parent_menu.ocw = m
parent_menu.addMenu(m)
return m
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(_('Sort alphabetically'), self.sort_alphabetically)
hidden = self.current_db.prefs['virt_libs_hidden']
if hidden:
s = m._s = m.addMenu(_('Restore hidden tabs'))
for x in hidden:
s.addAction(x, partial(self.restore, x))
m.addAction(_('Hide virtual library tabs'), self.disable_bar)
i = self.tabAt(ev.pos())
if i > -1:
vl = unicode(self.tabData(i) or '')
if vl:
m.addSeparator()
m.addAction(_('Edit "%s"') % vl, partial(self.gui.do_create_edit, name=vl))
m.addAction(_('Delete "%s"') % vl, partial(self.gui.remove_vl_triggered, name=vl))
m.exec_(ev.globalPos())
def genesis(self):
md = self.qaction.menu()
cm = partial(self.create_menu_action, md)
cm(
"individual",
_("Edit metadata individually"),
icon=self.qaction.icon(),
triggered=partial(self.edit_metadata, False, bulk=False),
)
md.addSeparator()
cm("bulk", _("Edit metadata in bulk"), triggered=partial(self.edit_metadata, False, bulk=True))
md.addSeparator()
cm(
"download",
_("Download metadata and covers"),
triggered=partial(self.download_metadata, ids=None),
shortcut="Ctrl+D",
)
self.metadata_menu = md
mb = QMenu()
cm2 = partial(self.create_menu_action, mb)
cm2("merge delete", _("Merge into first selected book - delete others"), triggered=self.merge_books)
mb.addSeparator()
cm2(
"merge keep",
_("Merge into first selected book - keep others"),
triggered=partial(self.merge_books, safe_merge=True),
shortcut="Alt+M",
)
mb.addSeparator()
cm2(
"merge formats",
_("Merge only formats into first selected book - delete others"),
triggered=partial(self.merge_books, merge_only_formats=True),
shortcut="Alt+Shift+M",
)
self.merge_menu = mb
md.addSeparator()
self.action_merge = cm(
"merge", _("Merge book records"), icon="merge_books.png", shortcut=_("M"), triggered=self.merge_books
)
self.action_merge.setMenu(mb)
self.qaction.triggered.connect(self.edit_metadata)
def show_context_menu(self, point):
item = self.itemAt(point)
if item is None or item in set(self.categories.itervalues()):
return
m = QMenu(self)
sel = self.selectedItems()
num = len(sel)
container = current_container()
ci = self.currentItem()
if ci is not None:
cn = unicode(ci.data(0, NAME_ROLE) or '')
mt = unicode(ci.data(0, MIME_ROLE) or '')
cat = unicode(ci.data(0, CATEGORY_ROLE) or '')
n = elided_text(cn.rpartition('/')[-1])
m.addAction(QIcon(I('save.png')), _('Export %s') % n, partial(self.export, cn))
if cn not in container.names_that_must_not_be_changed and cn not in container.names_that_must_not_be_removed and mt not in OEB_FONTS:
m.addAction(_('Replace %s with file...') % n, partial(self.replace, cn))
if num > 1:
m.addAction(QIcon(I('save.png')), _('Export all %d selected files') % num, self.export_selected)
m.addSeparator()
m.addAction(QIcon(I('modified.png')), _('&Rename %s') % n, self.edit_current_item)
if is_raster_image(mt):
m.addAction(QIcon(I('default_cover.png')), _('Mark %s as cover image') % n, partial(self.mark_as_cover, cn))
elif current_container().SUPPORTS_TITLEPAGES and mt in OEB_DOCS and cat == 'text':
m.addAction(QIcon(I('default_cover.png')), _('Mark %s as cover page') % n, partial(self.mark_as_titlepage, cn))
m.addSeparator()
if num > 0:
m.addSeparator()
if num > 1:
m.addAction(QIcon(I('modified.png')), _('&Bulk rename the selected files'), self.request_bulk_rename)
m.addAction(QIcon(I('modified.png')), _('Change the file extension for the selected files'), self.request_change_ext)
m.addAction(QIcon(I('trash.png')), ngettext(
'&Delete the selected file', '&Delete the {} selected files', num).format(num), self.request_delete)
m.addSeparator()
selected_map = defaultdict(list)
for item in sel:
selected_map[unicode(item.data(0, CATEGORY_ROLE) or '')].append(unicode(item.data(0, NAME_ROLE) or ''))
for items in selected_map.itervalues():
items.sort(key=self.index_of_name)
if selected_map['text']:
m.addAction(QIcon(I('format-text-color.png')), _('Link &stylesheets...'), partial(self.link_stylesheets, selected_map['text']))
if len(selected_map['text']) > 1:
m.addAction(QIcon(I('merge.png')), _('&Merge selected text files'), partial(self.start_merge, 'text', selected_map['text']))
if len(selected_map['styles']) > 1:
m.addAction(QIcon(I('merge.png')), _('&Merge selected style files'), partial(self.start_merge, 'styles', selected_map['styles']))
if len(list(m.actions())) > 0:
m.popup(self.mapToGlobal(point))
def eventFilter(self, obj, event):
base = super(Central, self)
if obj is not self.editor_tabs.tabBar() or event.type() != QEvent.MouseButtonPress or event.button() not in (Qt.RightButton, Qt.MidButton):
return base.eventFilter(obj, event)
index = self.editor_tabs.tabBar().tabAt(event.pos())
if index < 0:
return base.eventFilter(obj, event)
if event.button() == Qt.MidButton:
self._close_requested(index)
ed = self.editor_tabs.widget(index)
if ed is not None:
menu = QMenu(self)
menu.addAction(actions['close-current-tab'].icon(), _('Close tab'), partial(self.close_requested.emit, ed))
menu.addSeparator()
menu.addAction(actions['close-all-but-current-tab'].icon(), _('Close other tabs'), partial(self.close_all_but, ed))
menu.exec_(self.editor_tabs.tabBar().mapToGlobal(event.pos()))
return True
def eventFilter(self, obj, event):
base = super(Central, self)
if obj is not self.editor_tabs.tabBar() or event.type() != QEvent.MouseButtonPress or event.button() not in (Qt.RightButton, Qt.MidButton):
return base.eventFilter(obj, event)
index = self.editor_tabs.tabBar().tabAt(event.pos())
if index < 0:
return base.eventFilter(obj, event)
if event.button() == Qt.MidButton:
self._close_requested(index)
ed = self.editor_tabs.widget(index)
if ed is not None:
menu = QMenu(self)
menu.addAction(actions['close-current-tab'].icon(), _('Close tab'), partial(self.close_requested.emit, ed))
menu.addSeparator()
menu.addAction(actions['close-all-but-current-tab'].icon(), _('Close other tabs'), partial(self.close_all_but, ed))
menu.exec_(self.editor_tabs.tabBar().mapToGlobal(event.pos()))
return True
def add_open_with_actions(self, menu, file_name):
from calibre.gui2.open_with import populate_menu, edit_programs
fmt = file_name.rpartition('.')[-1].lower()
if not fmt:
return
m = QMenu(_('Open %s with...') % file_name)
def connect_action(ac, entry):
connect_lambda(ac.triggered, self, lambda self: self.open_with(file_name, fmt, entry))
populate_menu(m, connect_action, fmt)
if len(m.actions()) == 0:
menu.addAction(_('Open %s with...') % file_name, partial(self.choose_open_with, file_name, fmt))
else:
m.addSeparator()
m.addAction(_('Add other application for %s files...') % fmt.upper(), partial(self.choose_open_with, file_name, fmt))
m.addAction(_('Edit Open With applications...'), partial(edit_programs, fmt, file_name))
menu.addMenu(m)
menu.ow = m
def contextMenuEvent(self, ev):
cm = QMenu(self)
paste = cm.addAction(_('Paste cover'))
copy = cm.addAction(_('Copy cover'))
save = cm.addAction(_('Save cover to disk'))
remove = cm.addAction(_('Remove cover'))
gc = cm.addAction(_('Generate cover from metadata'))
cm.addSeparator()
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
remove.triggered.connect(self.remove_cover)
gc.triggered.connect(self.generate_cover)
save.triggered.connect(self.save_cover)
create_open_cover_with_menu(self, cm)
cm.si = m = create_search_internet_menu(self.search_internet.emit)
cm.addMenu(m)
cm.exec_(ev.globalPos())
def details_context_menu_event(view, ev, book_info, add_popup_action=False):
url = view.anchorAt(ev.pos())
menu = QMenu(view)
menu.addAction(QIcon(I('edit-copy.png')), _('Copy all book details'),
partial(copy_all, view))
cm = QMenu(_('Copy link to book'), menu)
cm.setIcon(QIcon(I('edit-copy.png')))
copy_links_added = False
search_internet_added = False
if url and url.startswith('action:'):
data = json_loads(from_hex_bytes(url.split(':', 1)[1]))
create_copy_links(cm, data)
copy_links_added = True
search_internet_added = add_item_specific_entries(
menu, data, book_info)
elif url and not url.startswith('#'):
ac = book_info.copy_link_action
ac.current_url = url
ac.setText(_('Copy link location'))
menu.addAction(ac)
if not copy_links_added:
create_copy_links(cm)
if list(cm.actions()):
menu.addMenu(cm)
if not search_internet_added and hasattr(book_info, 'search_internet'):
menu.addSeparator()
menu.si = create_search_internet_menu(book_info.search_internet)
menu.addMenu(menu.si)
for ac in tuple(menu.actions()):
if not ac.isEnabled():
menu.removeAction(ac)
if add_popup_action:
menu.addSeparator()
ac = menu.addAction(_('Open the Book details window'))
ac.triggered.connect(book_info.show_book_info)
if len(menu.actions()) > 0:
menu.exec_(ev.globalPos())
def contextMenuEvent(self, ev):
from calibre.gui2.open_with import populate_menu
cm = QMenu(self)
paste = cm.addAction(_('Paste Cover'))
copy = cm.addAction(_('Copy Cover'))
remove = cm.addAction(_('Remove Cover'))
gc = cm.addAction(_('Generate Cover from metadata'))
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
remove.triggered.connect(self.remove_cover)
gc.triggered.connect(self.generate_cover)
m = QMenu(_('Open with...'))
populate_menu(m, self.open_with, 'jpeg')
if len(m.actions()) == 0:
cm.addAction(_('Open with...'), self.choose_open_with)
else:
m.addSeparator()
m.addAction(_('Choose other program...'), self.choose_open_with)
cm.addMenu(m)
cm.exec_(ev.globalPos())
def contextMenuEvent(self, ev):
from calibre.gui2.open_with import populate_menu, edit_programs
cm = QMenu(self)
paste = cm.addAction(_('Paste Cover'))
copy = cm.addAction(_('Copy Cover'))
remove = cm.addAction(_('Remove Cover'))
gc = cm.addAction(_('Generate Cover from metadata'))
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
remove.triggered.connect(self.remove_cover)
gc.triggered.connect(self.generate_cover)
m = QMenu(_('Open cover with...'))
populate_menu(m, self.open_with, 'cover_image')
if len(m.actions()) == 0:
cm.addAction(_('Open cover with...'), self.choose_open_with)
else:
m.addSeparator()
m.addAction(_('Add another application to open cover...'), self.choose_open_with)
m.addAction(_('Edit Open With applications...'), partial(edit_programs, 'cover_image', self))
cm.addMenu(m)
cm.exec_(ev.globalPos())
class EpubMergePlugin(InterfaceAction):
name = 'EpubMerge'
# Declare the main action associated with this plugin
# The keyboard shortcut can be None if you dont want to use a keyboard
# shortcut. Remember that currently calibre has no central management for
# keyboard shortcuts, so try to use an unusual/unused shortcut.
# (text, icon_path, tooltip, keyboard shortcut)
# icon_path isn't in the zip--icon loaded below.
action_spec = (_('EpubMerge'), None,
_('Merge multiple EPUBs into one in a new book.'), ())
# None for keyboard shortcut doesn't allow shortcut. () does, there just isn't one yet
action_type = 'global'
# make button menu drop down only
#popup_type = QToolButton.InstantPopup
# disable when not in library. (main,carda,cardb)
def location_selected(self, loc):
enabled = loc == 'library'
self.qaction.setEnabled(enabled)
self.menuless_qaction.setEnabled(enabled)
def genesis(self):
# This method is called once per plugin, do initial setup here
base = self.interface_action_base_plugin
self.version = base.name+" v%d.%d.%d"%base.version
# Read the plugin icons and store for potential sharing with the config widget
icon_resources = self.load_resources(PLUGIN_ICONS)
set_plugin_icon_resources(self.name, icon_resources)
# Set the icon for this interface action
# The get_icons function is a builtin function defined for all your
# plugin code. It loads icons from the plugin zip file. It returns
# QIcon objects, if you want the actual data, use the analogous
# get_resources builtin function.
# Note that if you are loading more than one icon, for performance, you
# should pass a list of names to get_icons. In this case, get_icons
# will return a dictionary mapping names to QIcons. Names that
# are not found in the zip file will result in null QIcons.
icon = get_icon('images/icon.png')
# The qaction is automatically created from the action_spec defined
# above
self.qaction.setIcon(icon)
# Call function when plugin triggered.
self.qaction.triggered.connect(self.plugin_button)
# Assign our menu to this action
self.menu = QMenu()
self.qaction.setMenu(self.menu)
def initialization_complete(self):
# setup menu.
self.merge_action = self.create_menu_item_ex(self.menu, _('&Merge Epubs'), image='images/icon.png',
unique_name=_('&Merge Epubs'),
triggered=self.plugin_button )
self.unmerge_action = self.create_menu_item_ex(self.menu, _('&UnMerge Epub'), image='images/unmerge.png',
unique_name=_('&UnMerge Epub'),
triggered=self.unmerge )
# print("platform.system():%s"%platform.system())
# print("platform.mac_ver()[0]:%s"%platform.mac_ver()[0])
if not self.check_macmenuhack(): # not platform.mac_ver()[0]: # Some macs crash on these menu items for unknown reasons.
do_user_config = self.interface_action_base_plugin.do_user_config
self.menu.addSeparator()
self.config_action = self.create_menu_item_ex(self.menu, _('&Configure Plugin'),
image= 'config.png',
unique_name=_('Configure EpubMerge'),
shortcut_name=_('Configure EpubMerge'),
triggered=partial(do_user_config,parent=self.gui))
self.gui.keyboard.finalize()
def create_menu_item_ex(self, parent_menu, menu_text, image=None, tooltip=None,
shortcut=None, triggered=None, is_checked=None, shortcut_name=None,
unique_name=None):
#print("create_menu_item_ex before %s"%menu_text)
ac = create_menu_action_unique(self, parent_menu, menu_text, image, tooltip,
shortcut, triggered, is_checked, shortcut_name, unique_name)
#print("create_menu_item_ex after %s"%menu_text)
return ac
## Kludgey, yes, but with the real configuration inside the
## library now, how else would a user be able to change this
## setting if it's crashing calibre?
def check_macmenuhack(self):
try:
return self.macmenuhack
except:
file_path = os.path.join(calibre_config_dir,
*("plugins/fanficfare_macmenuhack.txt".split('/')))
file_path = os.path.abspath(file_path)
print("macmenuhack file_path:%s"%file_path)
self.macmenuhack = os.access(file_path, os.F_OK)
return self.macmenuhack
def do_unmerge(self, *args, **kwargs):
'''Also called by FFDL plugin.'''
return doUnMerge(*args, **kwargs)
def do_merge(self, *args, **kwargs):
'''Also called by FFDL plugin.'''
return doMerge(*args, **kwargs)
def unmerge(self):
if len(self.gui.library_view.get_selected_ids()) != 1:
d = error_dialog(self.gui,
_('Select One Book'),
_('Please select exactly one book to UnMerge.'),
show_copy_button=False)
d.exec_()
else:
db=self.gui.current_db
book_id=self.gui.library_view.get_selected_ids()[0]
if db.has_format(book_id,'EPUB',index_is_id=True):
epub = StringIO(db.format(book_id,'EPUB',index_is_id=True))
else:
d = error_dialog(self.gui,
_('Cannot UnMerge Non-Epubs'),
_('To UnMerge the source must be Epub(s) created by EpubMerge with Keep UnMerge Metadata enabled.'),
show_copy_button=False)
d.exec_()
remove_dir(tdir)
return
tdir = PersistentTemporaryDirectory(prefix='epubmerge_')
print("tdir:%s"%tdir)
outfilenames = self.do_unmerge(epub,tdir)
if not outfilenames:
d = error_dialog(self.gui,
_('No UnMerge data found'),
_('To UnMerge the source must be Epub(s) created by EpubMerge with Keep UnMerge Metadata enabled.'),
show_copy_button=False)
d.exec_()
return
#db.import_book_directory_multiple(tdir) XXX
#self.gui.library_view.model().books_added(len(outfilenames))
added_list=[]
updated_list=[]
for formats in db.find_books_in_directory(tdir, False):
#print("formats:%s"%formats)
mi = metadata_from_formats(formats)
#print("mi:%s"%mi)
state = 'add'
identicalbooks = db.find_identical_books(mi)
if identicalbooks:
if len(identicalbooks) == 1:
text = _("You already have a book <i>%s</i> by <i>%s</i>. You may Add a new book of the same title, Overwrite the Epub in the existing book, or Discard this Epub.")%(mi.title,", ".join(mi.authors))
over=True
else:
text = _("You already have more than one book <i>%s</i> by <i>%s</i>. You may Add a new book of the same title, or Discard this Epub.")%(mi.title,", ".join(mi.authors))
over=False
d = AddOverDiscardDialog(self.gui,self.qaction.icon(),text,over=over)
d.exec_()
state=d.state
if not state or state == 'discard':
continue
elif state == 'add':
book_id = db.create_book_entry(mi,
add_duplicates=True)
added_list.append(book_id)
else:
book_id = identicalbooks.pop()
db.add_format_with_hooks(book_id,
'EPUB',
formats[0], index_is_id=True)
updated_list.append(book_id)
if len(added_list):
self.gui.library_view.model().books_added(len(added_list))
if len(updated_list):
self.gui.library_view.model().refresh_ids(updated_list)
remove_dir(tdir)
def plugin_button(self):
self.t = time.time()
if len(self.gui.library_view.get_selected_ids()) < 2:
d = error_dialog(self.gui,
_('Cannot Merge Epubs'),
_('Less than 2 books selected.'),
show_copy_button=False)
d.exec_()
else:
db=self.gui.current_db
print("1:%s"%(time.time()-self.t))
self.t = time.time()
book_list = map( partial(self._convert_id_to_book, good=False), self.gui.library_view.get_selected_ids() )
# book_ids = self.gui.library_view.get_selected_ids()
LoopProgressDialog(self.gui,
book_list,
partial(self._populate_book_from_calibre_id, db=self.gui.current_db),
self._start_merge,
init_label=_("Collecting EPUBs for merger..."),
win_title=_("Get EPUBs for merge"),
status_prefix=_("EPUBs collected"))
def _start_merge(self,book_list):
db=self.gui.current_db
self.previous = self.gui.library_view.currentIndex()
# if any bad, bail.
bad_list = filter(lambda x : not x['good'], book_list)
if len(bad_list) > 0:
d = error_dialog(self.gui,
_('Cannot Merge Epubs'),
_('%s books failed.')%len(bad_list),
det_msg='\n'.join(map(lambda x : x['error'] , bad_list)))
d.exec_()
else:
d = OrderEPUBsDialog(self.gui,
_('Order EPUBs to Merge'),
prefs,
self.qaction.icon(),
book_list,
)
d.exec_()
if d.result() != d.Accepted:
return
book_list = d.get_books()
print("2:%s"%(time.time()-self.t))
self.t = time.time()
deftitle = "%s %s" % (book_list[0]['title'],prefs['mergeword'])
mi = MetaInformation(deftitle,["Temp Author"])
# if all same series, use series for name. But only if all.
serieslist = map(lambda x : x['series'], filter(lambda x : x['series'] != None, book_list))
if len(serieslist) == len(book_list):
mi.title = serieslist[0]
for sr in serieslist:
if mi.title != sr:
mi.title = deftitle;
break
# print("======================= mi.title:\n%s\n========================="%mi.title)
mi.authors = list()
authorslists = map(lambda x : x['authors'], book_list)
for l in authorslists:
for a in l:
if a not in mi.authors:
mi.authors.append(a)
#mi.authors = [item for sublist in authorslists for item in sublist]
# print("======================= mi.authors:\n%s\n========================="%mi.authors)
#mi.author_sort = ' & '.join(map(lambda x : x['author_sort'], book_list))
# print("======================= mi.author_sort:\n%s\n========================="%mi.author_sort)
# set publisher if all from same publisher.
publishers = set(map(lambda x : x['publisher'], book_list))
if len(publishers) == 1:
mi.publisher = publishers.pop()
# print("======================= mi.publisher:\n%s\n========================="%mi.publisher)
tagslists = map(lambda x : x['tags'], book_list)
mi.tags = [item for sublist in tagslists for item in sublist]
mi.tags.extend(prefs['mergetags'].split(','))
# print("======================= mergetags:\n%s\n========================="%prefs['mergetags'])
# print("======================= m.tags:\n%s\n========================="%mi.tags)
languageslists = map(lambda x : x['languages'], book_list)
mi.languages = [item for sublist in languageslists for item in sublist]
mi.series = ''
# ======================= make book comments =========================
if len(mi.authors) > 1:
booktitle = lambda x : _("%s by %s") % (x['title'],' & '.join(x['authors']))
else:
booktitle = lambda x : x['title']
mi.comments = (_("%s containing:")+"\n\n") % prefs['mergeword']
if prefs['includecomments']:
def bookcomments(x):
if x['comments']:
return '<b>%s</b>\n\n%s'%(booktitle(x),x['comments'])
else:
return '<b>%s</b>\n'%booktitle(x)
mi.comments += ('<div class="mergedbook">' +
'<hr></div><div class="mergedbook">'.join([ bookcomments(x) for x in book_list]) +
'</div>')
else:
mi.comments += '\n'.join( [ booktitle(x) for x in book_list ] )
# ======================= make book entry =========================
book_id = db.create_book_entry(mi,
add_duplicates=True)
# set default cover to same as first book
coverdata = db.cover(book_list[0]['calibre_id'],index_is_id=True)
if coverdata:
db.set_cover(book_id, coverdata)
# ======================= custom columns ===================
print("3:%s"%(time.time()-self.t))
self.t = time.time()
# have to get custom from db for each book.
idslist = map(lambda x : x['calibre_id'], book_list)
custom_columns = self.gui.library_view.model().custom_columns
for col, action in prefs['custom_cols'].iteritems():
#print("col: %s action: %s"%(col,action))
if col not in custom_columns:
print("%s not an existing column, skipping."%col)
continue
coldef = custom_columns[col]
#print("coldef:%s"%coldef)
if action not in permitted_values[coldef['datatype']]:
print("%s not a valid column type for %s, skipping."%(col,action))
continue
label = coldef['label']
found = False
value = None
idx = None
if action == 'first':
idx = 0
if action == 'last':
idx = -1
if action in ['first','last']:
value = db.get_custom(idslist[idx], label=label, index_is_id=True)
if coldef['datatype'] == 'series' and value != None:
# get the number-in-series, too.
value = "%s [%s]"%(value, db.get_custom_extra(idslist[idx], label=label, index_is_id=True))
found = True
if action in ('add','average','averageall'):
value = 0.0
count = 0
for bid in idslist:
try:
value += db.get_custom(bid, label=label, index_is_id=True)
found = True
# only count ones with values unless averageall
count += 1
except:
# if not set, it's None and fails.
# only count ones with values unless averageall
if action == 'averageall':
count += 1
if found and action in ('average','averageall'):
value = value / count
if coldef['datatype'] == 'int':
value += 0.5 # so int rounds instead of truncs.
if action == 'and':
value = True
for bid in idslist:
try:
value = value and db.get_custom(bid, label=label, index_is_id=True)
found = True
except:
# if not set, it's None and fails.
pass
if action == 'or':
value = False
for bid in idslist:
try:
value = value or db.get_custom(bid, label=label, index_is_id=True)
found = True
except:
# if not set, it's None and fails.
pass
if action == 'newest':
value = None
for bid in idslist:
try:
ivalue = db.get_custom(bid, label=label, index_is_id=True)
if not value or ivalue > value:
value = ivalue
found = True
except:
# if not set, it's None and fails.
pass
if action == 'oldest':
value = None
for bid in idslist:
try:
ivalue = db.get_custom(bid, label=label, index_is_id=True)
if not value or ivalue < value:
value = ivalue
found = True
except:
# if not set, it's None and fails.
pass
if action == 'union':
if not coldef['is_multiple']:
action = 'concat'
else:
value = set()
for bid in idslist:
try:
value = value.union(db.get_custom(bid, label=label, index_is_id=True))
found = True
except:
# if not set, it's None and fails.
pass
if action == 'concat':
value = ""
for bid in idslist:
try:
value = value + ' ' + db.get_custom(bid, label=label, index_is_id=True)
found = True
except:
# if not set, it's None and fails.
pass
value = value.strip()
if found and value != None:
db.set_custom(book_id,value,label=label,commit=False)
db.commit()
print("4:%s"%(time.time()-self.t))
self.t = time.time()
self.gui.library_view.model().books_added(1)
self.gui.library_view.select_rows([book_id])
print("5:%s"%(time.time()-self.t))
self.t = time.time()
confirm('\n'+_('''The book for the new Merged EPUB has been created and default metadata filled in.
However, the EPUB will *not* be created until after you've reviewed, edited, and closed the metadata dialog that follows.'''),
'epubmerge_created_now_edit_again',
self.gui)
self.gui.iactions['Edit Metadata'].edit_metadata(False)
print("5:%s"%(time.time()-self.t))
self.t = time.time()
self.gui.tags_view.recount()
totalsize = sum(map(lambda x : x['epub_size'], book_list))
print("merging %s EPUBs totaling %s"%(len(book_list),gethumanreadable(totalsize)))
if len(book_list) > 100 or totalsize > 5*1024*1024:
confirm('\n'+_('''You're merging %s EPUBs totaling %s. Calibre will be locked until the merge is finished.''')%(len(book_list),gethumanreadable(totalsize)),
'epubmerge_edited_now_merge_again',
self.gui)
self.gui.status_bar.show_message(_('Merging %s EPUBs...')%len(book_list), 60000)
mi = db.get_metadata(book_id,index_is_id=True)
mergedepub = PersistentTemporaryFile(suffix='.epub')
epubstomerge = map(lambda x : x['epub'] , book_list)
coverjpgpath = None
if mi.has_cover:
# grab the path to the real image.
coverjpgpath = os.path.join(db.library_path, db.path(book_id, index_is_id=True), 'cover.jpg')
self.do_merge( mergedepub,
epubstomerge,
authoropts=mi.authors,
titleopt=mi.title,
descopt=mi.comments,
tags=mi.tags,
languages=mi.languages,
titlenavpoints=prefs['titlenavpoints'],
flattentoc=prefs['flattentoc'],
printtimes=True,
coverjpgpath=coverjpgpath,
keepmetadatafiles=prefs['keepmeta'] )
print("6:%s"%(time.time()-self.t))
print(_("Merge finished, output in:\n%s")%mergedepub.name)
self.t = time.time()
db.add_format_with_hooks(book_id,
'EPUB',
mergedepub, index_is_id=True)
print("7:%s"%(time.time()-self.t))
self.t = time.time()
self.gui.status_bar.show_message(_('Finished merging %s EPUBs.')%len(book_list), 3000)
self.gui.library_view.model().refresh_ids([book_id])
self.gui.tags_view.recount()
current = self.gui.library_view.currentIndex()
self.gui.library_view.model().current_changed(current, self.previous)
#self.gui.iactions['View'].view_book(False)
def apply_settings(self):
# No need to do anything with perfs here, but we could.
prefs
def _convert_id_to_book(self, idval, good=True):
book = {}
book['good'] = good
book['calibre_id'] = idval
book['title'] = _('Unknown')
book['author'] = _('Unknown')
book['author_sort'] = _('Unknown')
book['error'] = ''
book['comments'] = ''
return book
def _populate_book_from_calibre_id(self, book, db=None):
mi = db.get_metadata(book['calibre_id'], index_is_id=True)
#book = {}
book['good'] = True
book['calibre_id'] = mi.id
book['title'] = mi.title
book['authors'] = mi.authors
book['author_sort'] = mi.author_sort
book['tags'] = mi.tags
book['series'] = mi.series
book['comments'] = mi.comments
book['publisher'] = mi.publisher
book['pubdate'] = mi.pubdate
if book['series']:
book['series_index'] = mi.series_index
else:
book['series_index'] = None
book['languages'] = mi.languages
book['error'] = ''
if db.has_format(mi.id,'EPUB',index_is_id=True):
book['epub'] = StringIO(db.format(mi.id,'EPUB',index_is_id=True))
if prefs['keepmeta']:
set_metadata(book['epub'], mi, stream_type='epub')
book['epub_size'] = len(book['epub'].getvalue())
else:
book['good'] = False;
book['error'] = _("%s by %s doesn't have an EPUB.")%(mi.title,', '.join(mi.authors))
class XRayCreatorInterfacePlugin(InterfaceAction):
'''Initializes plugin's interface'''
name = 'X-Ray Creator'
# Set main action and keyboard shortcut
action_spec = ('X-Ray Creator', None, 'Run X-Ray Creator', 'Ctrl+Shift+Alt+X')
popup_type = QToolButton.InstantPopup
action_type = 'current'
def __init__(self, parent, site_customization):
InterfaceAction.__init__(self, parent, site_customization)
https_proxy = get_proxies(debug=False).get('https', None)
if https_proxy:
https_address = ':'.join(https_proxy.split(':')[:-1])
https_port = int(https_proxy.split(':')[-1])
goodreads_conn = HTTPSConnection(https_address, https_port)
goodreads_conn.set_tunnel('www.goodreads.com', 443)
amazon_conn = HTTPSConnection(https_address, https_port)
amazon_conn.set_tunnel('www.amazon.com', 443)
else:
goodreads_conn = HTTPSConnection('www.goodreads.com')
amazon_conn = HTTPSConnection('www.amazon.com')
self._connections = {'goodreads': goodreads_conn, 'amazon': amazon_conn}
self.menu = QMenu(self.gui)
def genesis(self):
'''Initial setup'''
icon = self.get_icon('icon.png')
self.create_menu_action(self.menu, 'Book Specific Preferences',
'Book Specific Preferences', None, 'CTRL+SHIFT+ALT+Z',
'Set preferences specific to the book', self.book_config)
self.create_menu_action(self.menu, 'X-Ray Creator Create/Update Button',
'Create/Update Files', None, 'CTRL+SHIFT+ALT+X',
'Create/Update files for chosen books', self.create_files)
self.create_menu_action(self.menu, 'Send Local Files to Device',
'Sends Files to Device', None, 'CTRL+SHIFT+ALT+C',
'Sends files to device', self.send_files)
self.menu.addSeparator()
self.create_menu_action(self.menu, 'X-Ray Creator Preferences Button',
'Preferences', None, None,
'Create X-Rays for Chosen Books', self.config)
self.menu.addSeparator()
self.create_menu_action(self.menu, 'Donate', 'Donate', None, None, 'Donate', self.donate)
self.qaction.setIcon(icon)
self.qaction.setMenu(self.menu)
def create_files(self):
'''Creates files depending on user's settings'''
xray_creator = self._get_books('Cannot create Files')
if xray_creator:
job = ThreadedJob('create_files', 'Creating Files', xray_creator.create_files_event,
((self.gui.current_db.new_api,)), {}, Dispatcher(self.created_files))
self.gui.job_manager.run_threaded_job(job)
def send_files(self):
'''Sends files depending on user's settings'''
xray_creator = self._get_books('Cannot send Files')
if xray_creator:
job = ThreadedJob('send_files', 'Sending Files to Device', xray_creator.send_files_event,
((self.gui.current_db.new_api,)), {}, Dispatcher(self.sent_files))
self.gui.job_manager.run_threaded_job(job)
@staticmethod
def donate():
webbrowser.open('https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=szarroug3%40gmail%2ecom&lc=US&item_name=X%2dRay%20Calibre%20Plugin&no_note=0¤cy_code=USD&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHostedGuest')
def book_config(self):
'''Opens up a dialog that allows user to set book specific preferences'''
database = self.gui.current_db.new_api
rows = self.gui.library_view.selectionModel().selectedRows()
if not rows or len(rows) == 0:
error_dialog(self.gui, 'Cannot set book preferences',
'No books selected', show=True)
return
book_ids = list(map(self.gui.library_view.model().id, rows))
book_settings_list = []
for book_id in book_ids:
book_settings = BookSettings(database, book_id, self._connections)
if len(book_settings.aliases) == 0 and book_settings.goodreads_url != '':
book_settings.update_aliases(book_settings.goodreads_url)
book_settings.save()
book_settings_list.append(book_settings)
BookConfigWidget(self.gui, book_settings_list)
def created_files(self, job):
'''Dispatcher for create_files'''
pass
def sent_files(self, job):
'''Dispatcher for send_files'''
pass
def _get_books(self, error_msg):
'''Gets selected books'''
database = self.gui.current_db.new_api
rows = self.gui.library_view.selectionModel().selectedRows()
if not rows or len(rows) == 0:
error_dialog(self.gui, error_msg,
'No books selected', show=True)
return None
book_ids = list(map(self.gui.library_view.model().id, rows))
# Initialize each book's information
books = []
for book_id in book_ids:
books.append(Book(database, book_id, self._connections, settings))
return XRayCreator(books, settings)
def config(self):
'''Opens up a dialog that allows user to set general preferences'''
self.interface_action_base_plugin.do_user_config(parent=self.gui)
def get_icon(self, icon_name):
"""
Check to see whether the icon exists as a Calibre resource
This will enable skinning if the user stores icons within a folder like:
...\AppData\Roaming\calibre\resources\images\Plugin Name\
"""
icon_path = os.path.join(config_dir, 'resources', 'images', self.name, icon_name)
if not os.path.exists(icon_path):
return get_icons(self.plugin_path, 'images/{0}'.format(icon_name))
pixmap = QPixmap()
pixmap.load(icon_path)
return QIcon(pixmap)
class XRayCreatorInterfacePlugin(InterfaceAction):
name = 'X-Ray Creator'
# Set main action and keyboard shortcut
action_spec = ('X-Ray Creator', None,
'Run X-Ray Creator', 'Ctrl+Shift+Alt+X')
popup_type = QToolButton.InstantPopup
action_type = 'current'
def genesis(self):
# initial setup here
self._spoilers = prefs['spoilers']
self._send_to_device = prefs['send_to_device']
self._create_xray_when_sending = prefs['create_xray_when_sending']
self._mobi = prefs['mobi']
self._azw3 = prefs['azw3']
icon = get_icons('images/icon.png')
self.menu = QMenu(self.gui)
self.create_menu_action(self.menu, 'Book Specific Preferences',
'Book Specific Preferences', None, 'CTRL+SHIFT+ALT+Z',
'Set preferences specific to the book', self.book_config)
self.create_menu_action(self.menu, 'X-Ray Creator Create/Update Button',
'Create/Update X-Rays', None, 'CTRL+SHIFT+ALT+X',
'Create/Update x-rays for chosen books', self.create_xrays)
self.create_menu_action(self.menu, 'Send Local X-Rays to Device',
'Sends X-Ray Files to Device', None, 'CTRL+SHIFT+ALT+C',
'Sends x-Ray files to device', self.send_xrays)
self.menu.addSeparator()
self.create_menu_action(self.menu, 'X-Ray Creator Preferences Button',
'Preferences', None, None,
'Create X-Rays for Chosen Books', self.config)
self.qaction.setIcon(icon)
self.qaction.setMenu(self.menu)
def apply_settings(self):
from calibre_plugins.xray_creator.config import prefs
self._spoilers = prefs['spoilers']
self._send_to_device = prefs['send_to_device']
self._create_xray_when_sending = prefs['create_xray_when_sending']
self._mobi = prefs['mobi']
self._azw3 = prefs['azw3']
def create_xrays(self):
xray_creator = self._get_books('Cannot create X-Rays')
if xray_creator:
job = ThreadedJob('create_xray', 'Creating X-Ray Files', xray_creator.create_xrays_event, (), {}, Dispatcher(self.created_xrays))
self.gui.job_manager.run_threaded_job(job)
def send_xrays(self):
xray_creator = self._get_books('Cannot send X-Rays')
if xray_creator:
job = ThreadedJob('create_xray', 'Sending X-Ray Files to Device', xray_creator.send_xrays_event, (), {}, Dispatcher(self.sent_xrays))
self.gui.job_manager.run_threaded_job(job)
def book_config(self):
db = self.gui.current_db
rows = self.gui.library_view.selectionModel().selectedRows()
if not rows or len(rows) == 0:
error_dialog(self.gui, 'Cannot set book preferences',
'No books selected', show=True)
return
ids = list(map(self.gui.library_view.model().id, rows))
db = db.new_api
book_configs = BookConfigWidget(db, ids, self.gui)
def created_xrays(self, job):
pass
def sent_xrays(self, job):
pass
def _get_books(self, error_msg):
from calibre.ebooks.metadata.meta import get_metadata, set_metadata
db = self.gui.current_db
rows = self.gui.library_view.selectionModel().selectedRows()
if not rows or len(rows) == 0:
error_dialog(self.gui, error_msg,
'No books selected', show=True)
return None
if not self._mobi and not self._azw3:
error_dialog(self.gui, error_msg,
'No formats chosen in preferences.', show=True)
return None
ids = list(map(self.gui.library_view.model().id, rows))
db = db.new_api
formats = []
if self._mobi:
formats.append('MOBI')
if self._azw3:
formats.append('AZW3')
xray_creator = XRayCreator(db, ids, formats=formats, spoilers=self._spoilers, send_to_device=self._send_to_device, create_xray=self._create_xray_when_sending)
return xray_creator
def config(self):
self.interface_action_base_plugin.do_user_config(self.gui)
class RulesDialog(Dialog):
def __init__(self, parent=None):
self.loaded_ruleset = None
Dialog.__init__(self, _('Edit tag mapper rules'), 'edit-tag-mapper-rules', parent=parent)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.edit_widget = w = Rules(self)
l.addWidget(w)
l.addWidget(self.bb)
self.save_button = b = self.bb.addButton(_('&Save'), self.bb.ActionRole)
b.setToolTip(_('Save this ruleset for later re-use'))
b.clicked.connect(self.save_ruleset)
self.load_button = b = self.bb.addButton(_('&Load'), self.bb.ActionRole)
b.setToolTip(_('Load a previously saved ruleset'))
self.load_menu = QMenu(self)
b.setMenu(self.load_menu)
self.build_load_menu()
self.test_button = b = self.bb.addButton(_('&Test rules'), self.bb.ActionRole)
b.clicked.connect(self.test_rules)
@property
def rules(self):
return self.edit_widget.rules
@rules.setter
def rules(self, rules):
self.edit_widget.rules = rules
def save_ruleset(self):
if not self.rules:
error_dialog(self, _('No rules'), _(
'Cannot save as no rules have been created'), show=True)
return
text, ok = QInputDialog.getText(self, _('Save ruleset as'), _(
'Enter a name for this ruleset:'), text=self.loaded_ruleset or '')
if ok and text:
if self.loaded_ruleset and text == self.loaded_ruleset:
if not question_dialog(self, _('Are you sure?'), _(
'A ruleset with the name "%s" already exists, do you want to replace it?') % text):
return
self.loaded_ruleset = text
rules = self.rules
if rules:
tag_maps[text] = self.rules
elif text in tag_maps:
del tag_maps[text]
self.build_load_menu()
def build_load_menu(self):
self.load_menu.clear()
if len(tag_maps):
for name, rules in tag_maps.iteritems():
self.load_menu.addAction(name).triggered.connect(partial(self.load_ruleset, name))
self.load_menu.addSeparator()
m = self.load_menu.addMenu(_('Delete saved rulesets'))
for name, rules in tag_maps.iteritems():
m.addAction(name).triggered.connect(partial(self.delete_ruleset, name))
else:
self.load_menu.addAction(_('No saved rulesets available'))
def load_ruleset(self, name):
self.rules = tag_maps[name]
self.loaded_ruleset = name
def delete_ruleset(self, name):
del tag_maps[name]
self.build_load_menu()
def test_rules(self):
Tester(self.rules, self).exec_()
def show_context_menu(self, pos):
m = QMenu(self)
a = m.addAction
c = self.editor.cursorForPosition(pos)
origc = QTextCursor(c)
current_cursor = self.editor.textCursor()
r = origr = self.editor.syntax_range_for_cursor(c)
if (r is None or not r.format.property(SPELL_PROPERTY)) and c.positionInBlock() > 0 and not current_cursor.hasSelection():
c.setPosition(c.position() - 1)
r = self.editor.syntax_range_for_cursor(c)
if r is not None and r.format.property(SPELL_PROPERTY):
word = self.editor.text_for_range(c.block(), r)
locale = self.editor.spellcheck_locale_for_cursor(c)
orig_pos = c.position()
c.setPosition(orig_pos - utf16_length(word))
found = False
self.editor.setTextCursor(c)
if self.editor.find_spell_word([word], locale.langcode, center_on_cursor=False):
found = True
fc = self.editor.textCursor()
if fc.position() < c.position():
self.editor.find_spell_word([word], locale.langcode, center_on_cursor=False)
spell_cursor = self.editor.textCursor()
if current_cursor.hasSelection():
# Restore the current cursor so that any selection is preserved
# for the change case actions
self.editor.setTextCursor(current_cursor)
if found:
suggestions = dictionaries.suggestions(word, locale)[:7]
if suggestions:
for suggestion in suggestions:
ac = m.addAction(suggestion, partial(self.editor.simple_replace, suggestion, cursor=spell_cursor))
f = ac.font()
f.setBold(True), ac.setFont(f)
m.addSeparator()
m.addAction(actions['spell-next'])
m.addAction(_('Ignore this word'), partial(self._nuke_word, None, word, locale))
dics = dictionaries.active_user_dictionaries
if len(dics) > 0:
if len(dics) == 1:
m.addAction(_('Add this word to the dictionary: {0}').format(dics[0].name), partial(
self._nuke_word, dics[0].name, word, locale))
else:
ac = m.addAction(_('Add this word to the dictionary'))
dmenu = QMenu(m)
ac.setMenu(dmenu)
for dic in dics:
dmenu.addAction(dic.name, partial(self._nuke_word, dic.name, word, locale))
m.addSeparator()
if origr is not None and origr.format.property(LINK_PROPERTY):
href = self.editor.text_for_range(origc.block(), origr)
m.addAction(_('Open %s') % href, partial(self.link_clicked.emit, href))
if origr is not None and (origr.format.property(TAG_NAME_PROPERTY) or origr.format.property(CSS_PROPERTY)):
word = self.editor.text_for_range(origc.block(), origr)
item_type = 'tag_name' if origr.format.property(TAG_NAME_PROPERTY) else 'css_property'
url = help_url(word, item_type, self.editor.highlighter.doc_name, extra_data=current_container().opf_version)
if url is not None:
m.addAction(_('Show help for: %s') % word, partial(open_url, url))
for x in ('undo', 'redo'):
ac = actions['editor-%s' % x]
if ac.isEnabled():
a(ac)
m.addSeparator()
for x in ('cut', 'copy', 'paste'):
ac = actions['editor-' + x]
if ac.isEnabled():
a(ac)
m.addSeparator()
m.addAction(_('&Select all'), self.editor.select_all)
if self.selected_text or self.has_marked_text:
update_mark_text_action(self)
m.addAction(actions['mark-selected-text'])
if self.syntax != 'css' and actions['editor-cut'].isEnabled():
cm = QMenu(_('Change &case'), m)
for ac in 'upper lower swap title capitalize'.split():
cm.addAction(actions['transform-case-' + ac])
m.addMenu(cm)
if self.syntax == 'html':
m.addAction(actions['multisplit'])
m.exec_(self.editor.viewport().mapToGlobal(pos))
def show_context_menu(self, point):
item = self.itemAt(point)
if item is None or item in set(self.categories.itervalues()):
return
m = QMenu(self)
sel = self.selectedItems()
num = len(sel)
container = current_container()
ci = self.currentItem()
if ci is not None:
cn = unicode(ci.data(0, NAME_ROLE) or "")
mt = unicode(ci.data(0, MIME_ROLE) or "")
cat = unicode(ci.data(0, CATEGORY_ROLE) or "")
n = elided_text(cn.rpartition("/")[-1])
m.addAction(QIcon(I("save.png")), _("Export %s") % n, partial(self.export, cn))
if (
cn not in container.names_that_must_not_be_changed
and cn not in container.names_that_must_not_be_removed
and mt not in OEB_FONTS
):
m.addAction(_("Replace %s with file...") % n, partial(self.replace, cn))
m.addSeparator()
m.addAction(QIcon(I("modified.png")), _("&Rename %s") % n, self.edit_current_item)
if is_raster_image(mt):
m.addAction(
QIcon(I("default_cover.png")), _("Mark %s as cover image") % n, partial(self.mark_as_cover, cn)
)
elif current_container().SUPPORTS_TITLEPAGES and mt in OEB_DOCS and cat == "text":
m.addAction(
QIcon(I("default_cover.png")), _("Mark %s as cover page") % n, partial(self.mark_as_titlepage, cn)
)
m.addSeparator()
if num > 0:
m.addSeparator()
if num > 1:
m.addAction(QIcon(I("modified.png")), _("&Bulk rename selected files"), self.request_bulk_rename)
m.addAction(QIcon(I("trash.png")), _("&Delete the %d selected file(s)") % num, self.request_delete)
m.addSeparator()
selected_map = defaultdict(list)
for item in sel:
selected_map[unicode(item.data(0, CATEGORY_ROLE) or "")].append(unicode(item.data(0, NAME_ROLE) or ""))
for items in selected_map.itervalues():
items.sort(key=self.index_of_name)
if selected_map["text"]:
m.addAction(
QIcon(I("format-text-color.png")),
_("Link &stylesheets..."),
partial(self.link_stylesheets, selected_map["text"]),
)
if len(selected_map["text"]) > 1:
m.addAction(
QIcon(I("merge.png")),
_("&Merge selected text files"),
partial(self.start_merge, "text", selected_map["text"]),
)
if len(selected_map["styles"]) > 1:
m.addAction(
QIcon(I("merge.png")),
_("&Merge selected style files"),
partial(self.start_merge, "styles", selected_map["styles"]),
)
if len(list(m.actions())) > 0:
m.popup(self.mapToGlobal(point))
class LocationManager(QObject): # {{{
locations_changed = pyqtSignal()
unmount_device = pyqtSignal()
location_selected = pyqtSignal(object)
configure_device = pyqtSignal()
update_device_metadata = pyqtSignal()
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.free = [-1, -1, -1]
self.count = 0
self.location_actions = QActionGroup(self)
self.location_actions.setExclusive(True)
self.current_location = 'library'
self._mem = []
self.tooltips = {}
self.all_actions = []
def ac(name, text, icon, tooltip):
icon = QIcon(I(icon))
ac = self.location_actions.addAction(icon, text)
setattr(self, 'location_' + name, ac)
ac.setAutoRepeat(False)
ac.setCheckable(True)
receiver = partial(self._location_selected, name)
ac.triggered.connect(receiver)
self.tooltips[name] = tooltip
m = QMenu(parent)
self._mem.append(m)
a = m.addAction(icon, tooltip)
a.triggered.connect(receiver)
if name != 'library':
self._mem.append(a)
a = m.addAction(QIcon(I('eject.png')), _('Eject this device'))
a.triggered.connect(self._eject_requested)
self._mem.append(a)
a = m.addAction(QIcon(I('config.png')),
_('Configure this device'))
a.triggered.connect(self._configure_requested)
self._mem.append(a)
a = m.addAction(QIcon(I('sync.png')),
_('Update cached metadata on device'))
a.triggered.connect(
lambda x: self.update_device_metadata.emit())
self._mem.append(a)
else:
ac.setToolTip(tooltip)
ac.setMenu(m)
ac.calibre_name = name
self.all_actions.append(ac)
return ac
self.library_action = ac('library', _('Library'), 'lt.png',
_('Show books in calibre library'))
ac('main', _('Device'), 'reader.png',
_('Show books in the main memory of the device'))
ac('carda', _('Card A'), 'sd.png', _('Show books in storage card A'))
ac('cardb', _('Card B'), 'sd.png', _('Show books in storage card B'))
def set_switch_actions(self, quick_actions, rename_actions, delete_actions,
switch_actions, choose_action):
self.switch_menu = self.library_action.menu()
if self.switch_menu:
self.switch_menu.addSeparator()
else:
self.switch_menu = QMenu()
self.switch_menu.addAction(choose_action)
self.cs_menus = []
for t, acs in [(_('Quick switch'), quick_actions),
(_('Rename library'), rename_actions),
(_('Delete library'), delete_actions)]:
if acs:
self.cs_menus.append(QMenu(t))
for ac in acs:
self.cs_menus[-1].addAction(ac)
self.switch_menu.addMenu(self.cs_menus[-1])
self.switch_menu.addSeparator()
for ac in switch_actions:
self.switch_menu.addAction(ac)
if self.switch_menu != self.library_action.menu():
self.library_action.setMenu(self.switch_menu)
def _location_selected(self, location, *args):
if location != self.current_location and hasattr(
self, 'location_' + location):
self.current_location = location
self.location_selected.emit(location)
getattr(self, 'location_' + location).setChecked(True)
def _eject_requested(self, *args):
self.unmount_device.emit()
def _configure_requested(self):
self.configure_device.emit()
def update_devices(self, cp=(None, None), fs=[-1, -1, -1], icon=None):
if icon is None:
icon = I('reader.png')
self.location_main.setIcon(QIcon(icon))
had_device = self.has_device
if cp is None:
cp = (None, None)
if isinstance(cp, (str, unicode)):
cp = (cp, None)
if len(fs) < 3:
fs = list(fs) + [0]
self.free[0] = fs[0]
self.free[1] = fs[1]
self.free[2] = fs[2]
cpa, cpb = cp
self.free[1] = fs[1] if fs[1] is not None and cpa is not None else -1
self.free[2] = fs[2] if fs[2] is not None and cpb is not None else -1
self.update_tooltips()
if self.has_device != had_device:
self.location_library.setChecked(True)
self.locations_changed.emit()
if not self.has_device:
self.location_library.trigger()
def update_tooltips(self):
for i, loc in enumerate(('main', 'carda', 'cardb')):
t = self.tooltips[loc]
if self.free[i] > -1:
t += u'\n\n%s ' % human_readable(self.free[i]) + _('available')
ac = getattr(self, 'location_' + loc)
ac.setToolTip(t)
ac.setWhatsThis(t)
ac.setStatusTip(t)
@property
def has_device(self):
return max(self.free) > -1
@property
def available_actions(self):
ans = [self.location_library]
for i, loc in enumerate(('main', 'carda', 'cardb')):
if self.free[i] > -1:
ans.append(getattr(self, 'location_' + loc))
return ans
class ExecMacroAction(InterfaceAction):
name = 'Exec Macro'
# Create our top-level menu/toolbar action (text, icon_path, tooltip, keyboard shortcut)
action_spec = ('Exec Macro', None, 'Execute current selected macro.', ())
action_type = 'current'
def genesis(self):
# This method is called once per plugin, do initial setup here
self.menu = QMenu(self.gui)
self.actions = {}
self.rebuild_menu()
self.qaction.setMenu(self.menu)
self.qaction.setIcon(get_icons('images/icon.png'))
self.qaction.triggered.connect(self.execute_current_macro)
def rebuild_menu(self):
self.menu.clear()
self.actions.clear()
macros = prefs['macros']
for name in sorted(macros):
action = self.create_menu_action_unique(
self.menu,
name,
tooltip=macros[name]['documentation'],
image='dot_red.png',
shortcut=None,
shortcut_name=None,
triggered=partial(self.execute_macro, name))
self.actions[name] = action
self.mark_current_macro()
self.menu.addSeparator()
self.create_menu_action_unique(self.menu,
_('Manage macros'),
tooltip=None,
image='config.png',
shortcut=None,
shortcut_name=None,
triggered=partial(
show_config_dialog, self))
self.delete_orphan_shortcuts()
def delete_orphan_shortcuts(self):
prefix = menu_action_unique_name(self, '')
to_del = {
sc
for sc in self.gui.keyboard.shortcuts if sc.startswith(prefix)
}
new_sc = {menu_action_unique_name(self, name) for name in self.actions}
new_sc.add(menu_action_unique_name(self, _('Manage macros')))
to_del -= new_sc
for sc in to_del:
self.gui.keyboard.unregister_shortcut(sc)
self.gui.keyboard.finalize()
def mark_current_macro(self):
for name, action in self.actions.iteritems():
action.setIconVisibleInMenu(name == prefs['current_macro'])
def execute_current_macro(self):
self.execute_macro(prefs['current_macro'])
def execute_macro(self, name):
if name != prefs['current_macro']:
prefs['current_macro'] = name
self.mark_current_macro()
macro = prefs['macros'].get(name, None)
if not macro:
return
log = GUILog()
log.outputs.append(ANSIStream())
try:
if macro.get('execfromfile'):
with open(macro['macrofile'], 'rU') as file:
self.execute(file, log)
elif macro['program']:
program = macro['program']
encoding = self.get_encoding(program)
if encoding:
program = program.encode(encoding)
self.execute(program, log)
except:
log.exception(_('Failed to execute macro'))
error_dialog(
self.gui,
_('Failed to execute macro'),
_('Failed to execute macro, click "Show details" for more information.'
),
det_msg=log.plain_text,
show=True)
def execute(self, program, log):
# exec(program, globals().copy(), locals().copy())
vars = globals().copy()
vars['self'] = self
vars['log'] = log
exec(program, vars)
def create_menu_action_unique(self,
parent_menu,
menu_text,
image=None,
tooltip=None,
shortcut=None,
triggered=None,
is_checked=None,
shortcut_name=None,
unique_name=None):
'''
Create a menu action with the specified criteria and action, using the new
InterfaceAction.create_menu_action() function which ensures that regardless of
whether a shortcut is specified it will appear in Preferences->Keyboard
'''
orig_shortcut = shortcut
kb = self.gui.keyboard
if unique_name is None:
unique_name = menu_text
if not shortcut == False:
full_unique_name = menu_action_unique_name(self, unique_name)
if full_unique_name in kb.shortcuts:
shortcut = False
else:
if shortcut is not None and not shortcut == False:
if len(shortcut) == 0:
shortcut = None
else:
shortcut = _(shortcut)
if shortcut_name is None:
shortcut_name = menu_text.replace('&', '')
ac = self.create_menu_action(parent_menu,
unique_name,
menu_text,
icon=None,
shortcut=shortcut,
description=tooltip,
triggered=triggered,
shortcut_name=shortcut_name)
if shortcut == False and not orig_shortcut == False:
if ac.calibre_shortcut_unique_name in self.gui.keyboard.shortcuts:
kb.replace_action(ac.calibre_shortcut_unique_name, ac)
if image:
ac.setIcon(QIcon(I(image)))
if is_checked is not None:
ac.setCheckable(True)
if is_checked:
ac.setChecked(True)
return ac
def get_encoding(self, txt):
decl_re = re.compile(r'^[ \t\f]*#.*coding[:=][ \t]*([-\w.]+)')
blank_re = re.compile(r'^[ \t\f]*(?:[#\r\n]|$)')
lines = txt.splitlines()
if len(lines) < 1:
return None
match = decl_re.match(lines[0])
if match:
return match.group(1)
if len(lines) < 2 or (not blank_re.match(lines[0])):
return None
match = decl_re.match(lines[1])
if match:
return match.group(1)
return None
class TagsView(QTreeView): # {{{
refresh_required = pyqtSignal()
tags_marked = pyqtSignal(object)
edit_user_category = pyqtSignal(object)
delete_user_category = pyqtSignal(object)
del_item_from_user_cat = pyqtSignal(object, object, object)
add_item_to_user_cat = pyqtSignal(object, object, object)
add_subcategory = pyqtSignal(object)
tags_list_edit = pyqtSignal(object, object, object)
saved_search_edit = pyqtSignal(object)
rebuild_saved_searches = pyqtSignal()
author_sort_edit = pyqtSignal(object, object, object, object, object)
tag_item_renamed = pyqtSignal()
search_item_renamed = pyqtSignal()
drag_drop_finished = pyqtSignal(object)
restriction_error = pyqtSignal()
tag_item_delete = pyqtSignal(object, object, object, object, object)
apply_tag_to_selected = pyqtSignal(object, object, object)
def __init__(self, parent=None):
QTreeView.__init__(self, parent=None)
self.setMouseTracking(True)
self.alter_tb = None
self.disable_recounting = False
self.setUniformRowHeights(True)
self.setIconSize(QSize(20, 20))
self.setTabKeyNavigation(True)
self.setAnimated(True)
self.setHeaderHidden(True)
self.setItemDelegate(TagDelegate(self))
self.made_connections = False
self.setAcceptDrops(True)
self.setDragEnabled(True)
self.setDragDropMode(self.DragDrop)
self.setDropIndicatorShown(True)
self.in_drag_drop = False
self.setAutoExpandDelay(500)
self.pane_is_visible = False
self.search_icon = QIcon(I('search.png'))
self.search_copy_icon = QIcon(I("search_copy_saved.png"))
self.user_category_icon = QIcon(I('tb_folder.png'))
self.edit_metadata_icon = QIcon(I('edit_input.png'))
self.delete_icon = QIcon(I('list_remove.png'))
self.rename_icon = QIcon(I('edit-undo.png'))
self._model = TagsModel(self)
self._model.search_item_renamed.connect(self.search_item_renamed)
self._model.refresh_required.connect(self.refresh_required,
type=Qt.QueuedConnection)
self._model.tag_item_renamed.connect(self.tag_item_renamed)
self._model.restriction_error.connect(self.restriction_error)
self._model.user_categories_edited.connect(self.user_categories_edited,
type=Qt.QueuedConnection)
self._model.drag_drop_finished.connect(self.drag_drop_finished)
self.set_look_and_feel()
# Allowing keyboard focus looks bad in the Qt Fusion style and is useless
# anyway since the enter/spacebar keys do nothing
self.setFocusPolicy(Qt.NoFocus)
QApplication.instance().palette_changed.connect(self.set_style_sheet, type=Qt.QueuedConnection)
def set_style_sheet(self):
stylish_tb = '''
QTreeView {
background-color: palette(window);
color: palette(window-text);
border: none;
}
'''
self.setStyleSheet('''
QTreeView::item {
border: 1px solid transparent;
padding-top:PADex;
padding-bottom:PADex;
}
QTreeView::item:hover {
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #e7effd, stop: 1 #cbdaf1);
border: 1px solid #bfcde4;
border-radius: 6px;
}
'''.replace('PAD', unicode_type(gprefs['tag_browser_item_padding'])) + (
'' if gprefs['tag_browser_old_look'] else stylish_tb))
def set_look_and_feel(self):
self.set_style_sheet()
self.setAlternatingRowColors(gprefs['tag_browser_old_look'])
self.itemDelegate().old_look = gprefs['tag_browser_old_look']
@property
def hidden_categories(self):
return self._model.hidden_categories
@property
def db(self):
return self._model.db
@property
def collapse_model(self):
return self._model.collapse_model
def set_pane_is_visible(self, to_what):
pv = self.pane_is_visible
self.pane_is_visible = to_what
if to_what and not pv:
self.recount()
def get_state(self):
state_map = {}
expanded_categories = []
hide_empty_categories = self.model().prefs['tag_browser_hide_empty_categories']
crmap = self._model.category_row_map()
for category in self._model.category_nodes:
if (category.category_key in self.hidden_categories or (
hide_empty_categories and len(category.child_tags()) == 0)):
continue
row = crmap.get(category.category_key)
if row is not None:
index = self._model.index(row, 0, QModelIndex())
if self.isExpanded(index):
expanded_categories.append(category.category_key)
states = [c.tag.state for c in category.child_tags()]
names = [(c.tag.name, c.tag.category) for c in category.child_tags()]
state_map[category.category_key] = dict(zip(names, states))
return expanded_categories, state_map
def reread_collapse_parameters(self):
self._model.reread_collapse_model(self.get_state()[1])
def set_database(self, db, alter_tb):
self._model.set_database(db)
self.alter_tb = alter_tb
self.pane_is_visible = True # because TagsModel.set_database did a recount
self.setModel(self._model)
self.setContextMenuPolicy(Qt.CustomContextMenu)
pop = self.db.CATEGORY_SORTS.index(config['sort_tags_by'])
self.alter_tb.sort_menu.actions()[pop].setChecked(True)
try:
match_pop = self.db.MATCH_TYPE.index(config['match_tags_type'])
except ValueError:
match_pop = 0
self.alter_tb.match_menu.actions()[match_pop].setChecked(True)
if not self.made_connections:
self.clicked.connect(self.toggle)
self.customContextMenuRequested.connect(self.show_context_menu)
self.refresh_required.connect(self.recount, type=Qt.QueuedConnection)
self.alter_tb.sort_menu.triggered.connect(self.sort_changed)
self.alter_tb.match_menu.triggered.connect(self.match_changed)
self.made_connections = True
self.refresh_signal_processed = True
db.add_listener(self.database_changed)
self.expanded.connect(self.item_expanded)
def database_changed(self, event, ids):
if self.refresh_signal_processed:
self.refresh_signal_processed = False
self.refresh_required.emit()
def user_categories_edited(self, user_cats, nkey):
state_map = self.get_state()[1]
self.db.new_api.set_pref('user_categories', user_cats)
self._model.rebuild_node_tree(state_map=state_map)
p = self._model.find_category_node('@'+nkey)
self.show_item_at_path(p)
@property
def match_all(self):
return (self.alter_tb and self.alter_tb.match_menu.actions()[1].isChecked())
def sort_changed(self, action):
for i, ac in enumerate(self.alter_tb.sort_menu.actions()):
if ac is action:
config.set('sort_tags_by', self.db.CATEGORY_SORTS[i])
self.recount()
break
def match_changed(self, action):
try:
for i, ac in enumerate(self.alter_tb.match_menu.actions()):
if ac is action:
config.set('match_tags_type', self.db.MATCH_TYPE[i])
except:
pass
def mousePressEvent(self, event):
if event.buttons() & Qt.LeftButton:
self.possible_drag_start = event.pos()
return QTreeView.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
dex = self.indexAt(event.pos())
if dex.isValid():
self.setCursor(Qt.PointingHandCursor)
else:
self.unsetCursor()
if not event.buttons() & Qt.LeftButton:
return
if self.in_drag_drop or not dex.isValid():
QTreeView.mouseMoveEvent(self, event)
return
# don't start drag/drop until the mouse has moved a bit.
if ((event.pos() - self.possible_drag_start).manhattanLength() <
QApplication.startDragDistance()):
QTreeView.mouseMoveEvent(self, event)
return
# Must deal with odd case where the node being dragged is 'virtual',
# created to form a hierarchy. We can't really drag this node, but in
# addition we can't allow drag recognition to notice going over some
# other node and grabbing that one. So we set in_drag_drop to prevent
# this from happening, turning it off when the user lifts the button.
self.in_drag_drop = True
if not self._model.flags(dex) & Qt.ItemIsDragEnabled:
QTreeView.mouseMoveEvent(self, event)
return
md = self._model.mimeData([dex])
pixmap = dex.data(DRAG_IMAGE_ROLE).pixmap(self.iconSize())
drag = QDrag(self)
drag.setPixmap(pixmap)
drag.setMimeData(md)
if (self._model.is_in_user_category(dex) or
self._model.is_index_on_a_hierarchical_category(dex)):
'''
Things break if we specify MoveAction as the default, which is
what we want for drag on hierarchical categories. Dragging user
categories stops working. Don't know why. To avoid the problem
we fix the action in dragMoveEvent.
'''
drag.exec_(Qt.CopyAction|Qt.MoveAction, Qt.CopyAction)
else:
drag.exec_(Qt.CopyAction)
def mouseReleaseEvent(self, event):
# Swallow everything except leftButton so context menus work correctly
if event.button() == Qt.LeftButton or self.in_drag_drop:
QTreeView.mouseReleaseEvent(self, event)
self.in_drag_drop = False
def mouseDoubleClickEvent(self, event):
# swallow these to avoid toggling and editing at the same time
pass
@property
def search_string(self):
tokens = self._model.tokens()
joiner = ' and ' if self.match_all else ' or '
return joiner.join(tokens)
def toggle_current_index(self):
ci = self.currentIndex()
if ci.isValid():
self.toggle(ci)
def toggle(self, index):
self._toggle(index, None)
def _toggle(self, index, set_to):
'''
set_to: if None, advance the state. Otherwise must be one of the values
in TAG_SEARCH_STATES
'''
modifiers = int(QApplication.keyboardModifiers())
exclusive = modifiers not in (Qt.CTRL, Qt.SHIFT)
if self._model.toggle(index, exclusive, set_to=set_to):
self.tags_marked.emit(self.search_string)
def conditional_clear(self, search_string):
if search_string != self.search_string:
self.clear()
def context_menu_handler(self, action=None, category=None,
key=None, index=None, search_state=None,
use_vl=None, is_first_letter=False):
if not action:
return
try:
if action == 'set_icon':
try:
path = choose_files(self, 'choose_category_icon',
_('Change icon for: %s')%key, filters=[
('Images', ['png', 'gif', 'jpg', 'jpeg'])],
all_files=False, select_only_single_file=True)
if path:
path = path[0]
p = QIcon(path).pixmap(QSize(128, 128))
d = os.path.join(config_dir, 'tb_icons')
if not os.path.exists(d):
os.makedirs(d)
with open(os.path.join(d, 'icon_' + sanitize_file_name(key)+'.png'), 'wb') as f:
f.write(pixmap_to_data(p, format='PNG'))
path = os.path.basename(f.name)
self._model.set_custom_category_icon(key, unicode_type(path))
self.recount()
except:
import traceback
traceback.print_exc()
return
if action == 'clear_icon':
self._model.set_custom_category_icon(key, None)
self.recount()
return
def set_completion_data(category):
try:
completion_data = self.db.new_api.all_field_names(category)
except:
completion_data = None
self.itemDelegate().set_completion_data(completion_data)
if action == 'edit_item_no_vl':
item = self.model().get_node(index)
item.use_vl = False
set_completion_data(category)
self.edit(index)
return
if action == 'edit_item_in_vl':
item = self.model().get_node(index)
item.use_vl = True
set_completion_data(category)
self.edit(index)
return
if action == 'delete_item_in_vl':
tag = index.tag
children = index.child_tags()
self.tag_item_delete.emit(key, tag.id, tag.original_name,
self.model().get_book_ids_to_use(),
children)
return
if action == 'delete_item_no_vl':
tag = index.tag
children = index.child_tags()
self.tag_item_delete.emit(key, tag.id, tag.original_name,
None, children)
return
if action == 'open_editor':
self.tags_list_edit.emit(category, key, is_first_letter)
return
if action == 'manage_categories':
self.edit_user_category.emit(category)
return
if action == 'search':
self._toggle(index, set_to=search_state)
return
if action == "raw_search":
from calibre.gui2.ui import get_gui
get_gui().get_saved_search_text(search_name='search:' + key)
return
if action == 'add_to_category':
tag = index.tag
if len(index.children) > 0:
for c in index.all_children():
self.add_item_to_user_cat.emit(category, c.tag.original_name,
c.tag.category)
self.add_item_to_user_cat.emit(category, tag.original_name,
tag.category)
return
if action == 'add_subcategory':
self.add_subcategory.emit(key)
return
if action == 'search_category':
self._toggle(index, set_to=search_state)
return
if action == 'delete_user_category':
self.delete_user_category.emit(key)
return
if action == 'delete_search':
self.model().db.saved_search_delete(key)
self.rebuild_saved_searches.emit()
return
if action == 'delete_item_from_user_category':
tag = index.tag
if len(index.children) > 0:
for c in index.children:
self.del_item_from_user_cat.emit(key, c.tag.original_name,
c.tag.category)
self.del_item_from_user_cat.emit(key, tag.original_name, tag.category)
return
if action == 'manage_searches':
self.saved_search_edit.emit(category)
return
if action == 'edit_authors':
self.author_sort_edit.emit(self, index, False, False, is_first_letter)
return
if action == 'edit_author_sort':
self.author_sort_edit.emit(self, index, True, False, is_first_letter)
return
if action == 'edit_author_link':
self.author_sort_edit.emit(self, index, False, True, False)
return
reset_filter_categories = True
if action == 'hide':
self.hidden_categories.add(category)
elif action == 'show':
self.hidden_categories.discard(category)
elif action == 'categorization':
changed = self.collapse_model != category
self._model.collapse_model = category
if changed:
reset_filter_categories = False
gprefs['tags_browser_partition_method'] = category
elif action == 'defaults':
self.hidden_categories.clear()
elif action == 'add_tag':
item = self.model().get_node(index)
if item is not None:
self.apply_to_selected_books(item)
return
elif action == 'remove_tag':
item = self.model().get_node(index)
if item is not None:
self.apply_to_selected_books(item, True)
return
self.db.new_api.set_pref('tag_browser_hidden_categories', list(self.hidden_categories))
if reset_filter_categories:
self._model.set_categories_filter(None)
self._model.rebuild_node_tree()
except Exception:
import traceback
traceback.print_exc()
return
def apply_to_selected_books(self, item, remove=False):
if item.type != item.TAG:
return
tag = item.tag
if not tag.category or not tag.original_name:
return
self.apply_tag_to_selected.emit(tag.category, tag.original_name, remove)
def show_context_menu(self, point):
def display_name(tag):
ans = tag.name
if tag.category == 'search':
n = tag.name
if len(n) > 45:
n = n[:45] + '...'
ans = "'" + n + "'"
elif tag.is_hierarchical and not tag.is_editable:
ans = tag.original_name
if ans:
ans = ans.replace('&', '&&')
return ans
index = self.indexAt(point)
self.context_menu = QMenu(self)
if index.isValid():
item = index.data(Qt.UserRole)
tag = None
tag_item = item
if item.type == TagTreeItem.TAG:
tag = item.tag
while item.type != TagTreeItem.CATEGORY:
item = item.parent
if item.type == TagTreeItem.CATEGORY:
if not item.category_key.startswith('@'):
while item.parent != self._model.root_item:
item = item.parent
category = unicode_type(item.name or '')
key = item.category_key
# Verify that we are working with a field that we know something about
if key not in self.db.field_metadata:
return True
fm = self.db.field_metadata[key]
# Did the user click on a leaf node?
if tag:
# If the user right-clicked on an editable item, then offer
# the possibility of renaming that item.
if tag.is_editable or tag.is_hierarchical:
# Add the 'rename' items to both interior and leaf nodes
if self.model().get_in_vl():
self.context_menu.addAction(self.rename_icon,
_('Rename %s in Virtual library')%display_name(tag),
partial(self.context_menu_handler, action='edit_item_in_vl',
index=index, category=key))
self.context_menu.addAction(self.rename_icon,
_('Rename %s')%display_name(tag),
partial(self.context_menu_handler, action='edit_item_no_vl',
index=index, category=key))
if tag.is_editable:
if key in ('tags', 'series', 'publisher') or \
self._model.db.field_metadata.is_custom_field(key):
if self.model().get_in_vl():
self.context_menu.addAction(self.delete_icon,
_('Delete %s in Virtual library')%display_name(tag),
partial(self.context_menu_handler, action='delete_item_in_vl',
key=key, index=tag_item))
self.context_menu.addAction(self.delete_icon,
_('Delete %s')%display_name(tag),
partial(self.context_menu_handler, action='delete_item_no_vl',
key=key, index=tag_item))
if key == 'authors':
self.context_menu.addAction(_('Edit sort for %s')%display_name(tag),
partial(self.context_menu_handler,
action='edit_author_sort', index=tag.id))
self.context_menu.addAction(_('Edit link for %s')%display_name(tag),
partial(self.context_menu_handler,
action='edit_author_link', index=tag.id))
# is_editable is also overloaded to mean 'can be added
# to a User category'
m = QMenu(_('Add %s to User category')%display_name(tag), self.context_menu)
m.setIcon(self.user_category_icon)
added = [False]
def add_node_tree(tree_dict, m, path):
p = path[:]
for k in sorted(tree_dict.keys(), key=sort_key):
p.append(k)
n = k[1:] if k.startswith('@') else k
m.addAction(self.user_category_icon, n,
partial(self.context_menu_handler,
'add_to_category',
category='.'.join(p), index=tag_item))
added[0] = True
if len(tree_dict[k]):
tm = m.addMenu(self.user_category_icon,
_('Children of %s')%n)
add_node_tree(tree_dict[k], tm, p)
p.pop()
add_node_tree(self.model().user_category_node_tree, m, [])
if added[0]:
self.context_menu.addMenu(m)
# is_editable also means the tag can be applied/removed
# from selected books
if fm['datatype'] != 'rating':
m = self.context_menu.addMenu(self.edit_metadata_icon,
_('Apply %s to selected books')%display_name(tag))
m.addAction(QIcon(I('plus.png')),
_('Add %s to selected books') % display_name(tag),
partial(self.context_menu_handler, action='add_tag', index=index))
m.addAction(QIcon(I('minus.png')),
_('Remove %s from selected books') % display_name(tag),
partial(self.context_menu_handler, action='remove_tag', index=index))
elif key == 'search' and tag.is_searchable:
self.context_menu.addAction(self.rename_icon,
_('Rename %s')%display_name(tag),
partial(self.context_menu_handler, action='edit_item_no_vl',
index=index))
self.context_menu.addAction(self.delete_icon,
_('Delete search %s')%display_name(tag),
partial(self.context_menu_handler,
action='delete_search', key=tag.original_name))
if key.startswith('@') and not item.is_gst:
self.context_menu.addAction(self.user_category_icon,
_('Remove %(item)s from category %(cat)s')%
dict(item=display_name(tag), cat=item.py_name),
partial(self.context_menu_handler,
action='delete_item_from_user_category',
key=key, index=tag_item))
if tag.is_searchable:
# Add the search for value items. All leaf nodes are searchable
self.context_menu.addAction(self.search_icon,
_('Search for %s')%display_name(tag),
partial(self.context_menu_handler, action='search',
search_state=TAG_SEARCH_STATES['mark_plus'],
index=index))
self.context_menu.addAction(self.search_icon,
_('Search for everything but %s')%display_name(tag),
partial(self.context_menu_handler, action='search',
search_state=TAG_SEARCH_STATES['mark_minus'],
index=index))
self.context_menu.addAction(self.search_copy_icon,
_('Search using saved search expression'),
partial(self.context_menu_handler, action='raw_search',
key=tag.name))
self.context_menu.addSeparator()
elif key.startswith('@') and not item.is_gst:
if item.can_be_edited:
self.context_menu.addAction(self.rename_icon,
_('Rename %s')%item.py_name,
partial(self.context_menu_handler, action='edit_item_no_vl',
index=index))
self.context_menu.addAction(self.user_category_icon,
_('Add sub-category to %s')%item.py_name,
partial(self.context_menu_handler,
action='add_subcategory', key=key))
self.context_menu.addAction(self.delete_icon,
_('Delete User category %s')%item.py_name,
partial(self.context_menu_handler,
action='delete_user_category', key=key))
self.context_menu.addSeparator()
# Hide/Show/Restore categories
self.context_menu.addAction(_('Hide category %s') % category,
partial(self.context_menu_handler, action='hide',
category=key))
if self.hidden_categories:
m = self.context_menu.addMenu(_('Show category'))
for col in sorted(self.hidden_categories,
key=lambda x: sort_key(self.db.field_metadata[x]['name'])):
m.addAction(self.db.field_metadata[col]['name'],
partial(self.context_menu_handler, action='show', category=col))
# search by category. Some categories are not searchable, such
# as search and news
if item.tag.is_searchable:
self.context_menu.addAction(self.search_icon,
_('Search for books in category %s')%category,
partial(self.context_menu_handler,
action='search_category',
index=self._model.createIndex(item.row(), 0, item),
search_state=TAG_SEARCH_STATES['mark_plus']))
self.context_menu.addAction(self.search_icon,
_('Search for books not in category %s')%category,
partial(self.context_menu_handler,
action='search_category',
index=self._model.createIndex(item.row(), 0, item),
search_state=TAG_SEARCH_STATES['mark_minus']))
# Offer specific editors for tags/series/publishers/saved searches
self.context_menu.addSeparator()
if key in ['tags', 'publisher', 'series'] or (
self.db.field_metadata[key]['is_custom'] and self.db.field_metadata[key]['datatype'] != 'composite'):
if tag_item.type == TagTreeItem.CATEGORY and tag_item.temporary:
self.context_menu.addAction(_('Manage %s')%category,
partial(self.context_menu_handler, action='open_editor',
category=tag_item.name,
key=key, is_first_letter=True))
else:
self.context_menu.addAction(_('Manage %s')%category,
partial(self.context_menu_handler, action='open_editor',
category=tag.original_name if tag else None,
key=key))
elif key == 'authors':
if tag_item.type == TagTreeItem.CATEGORY:
if tag_item.temporary:
self.context_menu.addAction(_('Manage %s')%category,
partial(self.context_menu_handler, action='edit_authors',
index=tag_item.name, is_first_letter=True))
else:
self.context_menu.addAction(_('Manage %s')%category,
partial(self.context_menu_handler, action='edit_authors'))
else:
self.context_menu.addAction(_('Manage %s')%category,
partial(self.context_menu_handler, action='edit_authors',
index=tag.id))
elif key == 'search':
self.context_menu.addAction(_('Manage Saved searches'),
partial(self.context_menu_handler, action='manage_searches',
category=tag.name if tag else None))
if tag is None:
self.context_menu.addSeparator()
self.context_menu.addAction(_('Change category icon'),
partial(self.context_menu_handler, action='set_icon', key=key))
self.context_menu.addAction(_('Restore default icon'),
partial(self.context_menu_handler, action='clear_icon', key=key))
# Always show the User categories editor
self.context_menu.addSeparator()
if key.startswith('@') and \
key[1:] in self.db.prefs.get('user_categories', {}).keys():
self.context_menu.addAction(_('Manage User categories'),
partial(self.context_menu_handler, action='manage_categories',
category=key[1:]))
else:
self.context_menu.addAction(_('Manage User categories'),
partial(self.context_menu_handler, action='manage_categories',
category=None))
if self.hidden_categories:
if not self.context_menu.isEmpty():
self.context_menu.addSeparator()
self.context_menu.addAction(_('Show all categories'),
partial(self.context_menu_handler, action='defaults'))
m = self.context_menu.addMenu(_('Change sub-categorization scheme'))
da = m.addAction(_('Disable'),
partial(self.context_menu_handler, action='categorization', category='disable'))
fla = m.addAction(_('By first letter'),
partial(self.context_menu_handler, action='categorization', category='first letter'))
pa = m.addAction(_('Partition'),
partial(self.context_menu_handler, action='categorization', category='partition'))
if self.collapse_model == 'disable':
da.setCheckable(True)
da.setChecked(True)
elif self.collapse_model == 'first letter':
fla.setCheckable(True)
fla.setChecked(True)
else:
pa.setCheckable(True)
pa.setChecked(True)
if config['sort_tags_by'] != "name":
fla.setEnabled(False)
m.hovered.connect(self.collapse_menu_hovered)
fla.setToolTip(_('First letter is usable only when sorting by name'))
# Apparently one cannot set a tooltip to empty, so use a star and
# deal with it in the hover method
da.setToolTip('*')
pa.setToolTip('*')
if index.isValid() and self.model().rowCount(index) > 0:
self.context_menu.addSeparator()
self.context_menu.addAction(_('E&xpand all children'), partial(self.expand_node_and_descendants, index))
self.context_menu.addAction(_('Collapse all levels'), self.collapseAll)
if not self.context_menu.isEmpty():
self.context_menu.popup(self.mapToGlobal(point))
return True
def expand_node_and_descendants(self, index):
if not index.isValid():
return
self.expand(index)
for r in range(self.model().rowCount(index)):
self.expand_node_and_descendants(index.child(r, 0))
def collapse_menu_hovered(self, action):
tip = action.toolTip()
if tip == '*':
tip = ''
QToolTip.showText(QCursor.pos(), tip)
def dragMoveEvent(self, event):
QTreeView.dragMoveEvent(self, event)
self.setDropIndicatorShown(False)
index = self.indexAt(event.pos())
if not index.isValid():
return
src_is_tb = event.mimeData().hasFormat('application/calibre+from_tag_browser')
item = index.data(Qt.UserRole)
if item.type == TagTreeItem.ROOT:
return
if src_is_tb:
src = json_loads(bytes(event.mimeData().data('application/calibre+from_tag_browser')))
if len(src) == 1:
src_item = self._model.get_node(self._model.index_for_path(src[0][5]))
if (src_item.type == TagTreeItem.TAG and
src_item.tag.category == item.tag.category and
not item.temporary and
self._model.is_key_a_hierarchical_category(src_item.tag.category)):
event.setDropAction(Qt.MoveAction)
self.setDropIndicatorShown(True)
return
if item.type == TagTreeItem.TAG and self._model.flags(index) & Qt.ItemIsDropEnabled:
event.setDropAction(Qt.CopyAction)
self.setDropIndicatorShown(not src_is_tb)
return
if item.type == TagTreeItem.CATEGORY and not item.is_gst:
fm_dest = self.db.metadata_for_field(item.category_key)
if fm_dest['kind'] == 'user':
if src_is_tb:
if event.dropAction() == Qt.MoveAction:
# src is initialized above
for s in src:
if s[0] == TagTreeItem.TAG and \
(not s[1].startswith('@') or s[2]):
return
self.setDropIndicatorShown(True)
return
md = event.mimeData()
if hasattr(md, 'column_name'):
fm_src = self.db.metadata_for_field(md.column_name)
if md.column_name in ['authors', 'publisher', 'series'] or \
(fm_src['is_custom'] and (
(fm_src['datatype'] in ['series', 'text', 'enumeration'] and not fm_src['is_multiple']) or (
fm_src['datatype'] == 'composite' and fm_src['display'].get('make_category', False)))):
self.setDropIndicatorShown(True)
def clear(self):
if self.model():
self.model().clear_state()
def is_visible(self, idx):
item = idx.data(Qt.UserRole)
if getattr(item, 'type', None) == TagTreeItem.TAG:
idx = idx.parent()
return self.isExpanded(idx)
def recount_with_position_based_index(self):
self._model.use_position_based_index_on_next_recount = True
self.recount()
def recount(self, *args):
'''
Rebuild the category tree, expand any categories that were expanded,
reset the search states, and reselect the current node.
'''
if self.disable_recounting or not self.pane_is_visible:
return
self.refresh_signal_processed = True
ci = self.currentIndex()
if not ci.isValid():
ci = self.indexAt(QPoint(10, 10))
use_pos = self._model.use_position_based_index_on_next_recount
self._model.use_position_based_index_on_next_recount = False
if use_pos:
path = self._model.path_for_index(ci) if self.is_visible(ci) else None
else:
path = self._model.named_path_for_index(ci) if self.is_visible(ci) else None
expanded_categories, state_map = self.get_state()
self._model.rebuild_node_tree(state_map=state_map)
self.blockSignals(True)
for category in expanded_categories:
idx = self._model.index_for_category(category)
if idx is not None and idx.isValid():
self.expand(idx)
if path is not None:
if use_pos:
self.show_item_at_path(path)
else:
index = self._model.index_for_named_path(path)
if index.isValid():
self.show_item_at_index(index)
self.blockSignals(False)
def show_item_at_path(self, path, box=False,
position=QTreeView.PositionAtCenter):
'''
Scroll the browser and open categories to show the item referenced by
path. If possible, the item is placed in the center. If box=True, a
box is drawn around the item.
'''
if path:
self.show_item_at_index(self._model.index_for_path(path), box=box,
position=position)
def expand_parent(self, idx):
# Needed otherwise Qt sometimes segfaults if the node is buried in a
# collapsed, off screen hierarchy. To be safe, we expand from the
# outermost in
p = self._model.parent(idx)
if p.isValid():
self.expand_parent(p)
self.expand(idx)
def show_item_at_index(self, idx, box=False,
position=QTreeView.PositionAtCenter):
if idx.isValid() and idx.data(Qt.UserRole) is not self._model.root_item:
self.expand_parent(idx)
self.setCurrentIndex(idx)
self.scrollTo(idx, position)
if box:
self._model.set_boxed(idx)
def item_expanded(self, idx):
'''
Called by the expanded signal
'''
self.setCurrentIndex(idx)
def details_context_menu_event(view, ev, book_info): # {{{
p = view.page()
mf = p.mainFrame()
r = mf.hitTestContent(ev.pos())
url = unicode(r.linkUrl().toString(NO_URL_FORMATTING)).strip()
menu = p.createStandardContextMenu()
ca = view.pageAction(p.Copy)
for action in list(menu.actions()):
if action is not ca:
menu.removeAction(action)
menu.addAction(QIcon(I('edit-copy.png')), _('Copy &all'), partial(copy_all, book_info))
search_internet_added = False
if not r.isNull():
if url.startswith('format:'):
parts = url.split(':')
try:
book_id, fmt = int(parts[1]), parts[2].upper()
except:
import traceback
traceback.print_exc()
else:
from calibre.gui2.ui import get_gui
from calibre.ebooks.oeb.polish.main import SUPPORTED
db = get_gui().current_db.new_api
ofmt = fmt.upper() if fmt.startswith('ORIGINAL_') else 'ORIGINAL_' + fmt
nfmt = ofmt[len('ORIGINAL_'):]
fmts = {x.upper() for x in db.formats(book_id)}
for a, t in [
('remove', _('Delete the %s format')),
('save', _('Save the %s format to disk')),
('restore', _('Restore the %s format')),
('compare', ''),
('set_cover', _('Set the book cover from the %s file')),
]:
if a == 'restore' and not fmt.startswith('ORIGINAL_'):
continue
if a == 'compare':
if ofmt not in fmts or nfmt not in SUPPORTED:
continue
t = _('Compare to the %s format') % (fmt[9:] if fmt.startswith('ORIGINAL_') else ofmt)
else:
t = t % fmt
ac = getattr(book_info, '%s_format_action'%a)
ac.current_fmt = (book_id, fmt)
ac.setText(t)
menu.addAction(ac)
if not fmt.upper().startswith('ORIGINAL_'):
from calibre.gui2.open_with import populate_menu, edit_programs
m = QMenu(_('Open %s with...') % fmt.upper())
populate_menu(m, partial(book_info.open_with, book_id, fmt), fmt)
if len(m.actions()) == 0:
menu.addAction(_('Open %s with...') % fmt.upper(), partial(book_info.choose_open_with, book_id, fmt))
else:
m.addSeparator()
m.addAction(_('Add other application for %s files...') % fmt.upper(), partial(book_info.choose_open_with, book_id, fmt))
m.addAction(_('Edit Open With applications...'), partial(edit_programs, fmt, book_info))
menu.addMenu(m)
menu.ow = m
ac = book_info.copy_link_action
ac.current_url = r.linkElement().attribute('data-full-path')
if ac.current_url:
ac.setText(_('&Copy path to file'))
menu.addAction(ac)
else:
el = r.linkElement()
data = el.attribute('data-item')
author = el.toPlainText() if unicode(el.attribute('calibre-data')) == u'authors' else None
if url and not url.startswith('search:'):
for a, t in [('copy', _('&Copy link')),
]:
ac = getattr(book_info, '%s_link_action'%a)
ac.current_url = url
if url.startswith('path:'):
ac.current_url = el.attribute('title')
ac.setText(t)
menu.addAction(ac)
if author is not None:
menu.addAction(init_manage_action(book_info.manage_action, 'authors', author))
if hasattr(book_info, 'search_internet'):
menu.sia = sia = create_search_internet_menu(book_info.search_internet, author)
menu.addMenu(sia)
search_internet_added = True
if hasattr(book_info, 'search_requested'):
menu.addAction(_('Search calibre for %s') % author,
lambda : book_info.search_requested('authors:"={}"'.format(author.replace('"', r'\"'))))
if data:
try:
field, value, book_id = cPickle.loads(unhexlify(data))
except Exception:
field = value = book_id = None
if field:
if author is None and (
field in ('tags', 'series', 'publisher') or is_category(field)):
menu.addAction(init_manage_action(book_info.manage_action, field, value))
ac = book_info.remove_item_action
ac.data = (field, value, book_id)
ac.setText(_('Remove %s from this book') % value)
menu.addAction(ac)
if not search_internet_added and hasattr(book_info, 'search_internet'):
menu.addSeparator()
menu.si = create_search_internet_menu(book_info.search_internet)
menu.addMenu(menu.si)
if len(menu.actions()) > 0:
menu.exec_(ev.globalPos())
class XRayCreatorInterfacePlugin(InterfaceAction):
'''Initializes plugin's interface'''
name = 'X-Ray Creator'
# Set main action and keyboard shortcut
action_spec = ('X-Ray Creator', None, 'Run X-Ray Creator', 'Ctrl+Shift+Alt+X')
popup_type = QToolButton.InstantPopup
action_type = 'current'
def __init__(self, parent, site_customization):
InterfaceAction.__init__(self, parent, site_customization)
https_proxy = get_proxies(debug=False).get('https', None)
if https_proxy:
https_address = ':'.join(https_proxy.split(':')[:-1])
https_port = int(https_proxy.split(':')[-1])
goodreads_conn = HTTPSConnection(https_address, https_port)
goodreads_conn.set_tunnel('www.goodreads.com', 443)
amazon_conn = HTTPSConnection(https_address, https_port)
amazon_conn.set_tunnel('www.amazon.com', 443)
else:
goodreads_conn = HTTPSConnection('www.goodreads.com')
amazon_conn = HTTPSConnection('www.amazon.com')
self._connections = {'goodreads': goodreads_conn, 'amazon': amazon_conn}
self.menu = QMenu(self.gui)
def genesis(self):
'''Initial setup'''
icon = self.get_icon('icon.png')
self.create_menu_action(self.menu, 'Book Specific Preferences',
'Book Specific Preferences', None, 'CTRL+SHIFT+ALT+Z',
'Set preferences specific to the book', self.book_config)
self.create_menu_action(self.menu, 'X-Ray Creator Create/Update Button',
'Create/Update Files', None, 'CTRL+SHIFT+ALT+X',
'Create/Update files for chosen books', self.create_files)
self.create_menu_action(self.menu, 'Send Local Files to Device',
'Sends Files to Device', None, 'CTRL+SHIFT+ALT+C',
'Sends files to device', self.send_files)
self.menu.addSeparator()
self.create_menu_action(self.menu, 'X-Ray Creator Preferences Button',
'Preferences', None, None,
'Create X-Rays for Chosen Books', self.config)
self.menu.addSeparator()
self.create_menu_action(self.menu, 'Donate', 'Donate', None, None, 'Donate', self.donate)
self.qaction.setIcon(icon)
self.qaction.setMenu(self.menu)
def create_files(self):
'''Creates files depending on user's settings'''
xray_creator = self._get_books('Cannot create Files')
if xray_creator:
job = ThreadedJob('create_files', 'Creating Files', xray_creator.create_files_event,
((self.gui.current_db.new_api,)), {}, Dispatcher(self.created_files))
self.gui.job_manager.run_threaded_job(job)
def send_files(self):
'''Sends files depending on user's settings'''
xray_creator = self._get_books('Cannot send Files')
if xray_creator:
job = ThreadedJob('send_files', 'Sending Files to Device', xray_creator.send_files_event,
((self.gui.current_db.new_api,)), {}, Dispatcher(self.sent_files))
self.gui.job_manager.run_threaded_job(job)
@staticmethod
def donate():
webbrowser.open('https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=szarroug3%40gmail%2ecom&lc=US&item_name=X%2dRay%20Calibre%20Plugin&no_note=0¤cy_code=USD&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHostedGuest')
def book_config(self):
'''Opens up a dialog that allows user to set book specific preferences'''
database = self.gui.current_db.new_api
rows = self.gui.library_view.selectionModel().selectedRows()
if not rows or len(rows) == 0:
error_dialog(self.gui, 'Cannot set book preferences',
'No books selected', show=True)
return
book_ids = list(map(self.gui.library_view.model().id, rows))
book_settings_list = []
for book_id in book_ids:
book_settings = BookSettings(database, book_id, self._connections)
if len(book_settings.aliases) == 0 and book_settings.goodreads_url != '':
book_settings.update_aliases(book_settings.goodreads_url)
book_settings.save()
book_settings_list.append(book_settings)
BookConfigWidget(self.gui, book_settings_list)
def created_files(self, job):
'''Dispatcher for create_files'''
pass
def sent_files(self, job):
'''Dispatcher for send_files'''
pass
def _get_books(self, error_msg):
'''Gets selected books'''
database = self.gui.current_db.new_api
rows = self.gui.library_view.selectionModel().selectedRows()
if not rows or len(rows) == 0:
error_dialog(self.gui, error_msg,
'No books selected', show=True)
return None
book_ids = list(map(self.gui.library_view.model().id, rows))
# Initialize each book's information
books = []
for book_id in book_ids:
books.append(Book(database, book_id, self._connections, settings))
return XRayCreator(books, settings)
def config(self):
'''Opens up a dialog that allows user to set general preferences'''
self.interface_action_base_plugin.do_user_config(parent=self.gui)
def get_icon(self, icon_name):
"""
Check to see whether the icon exists as a Calibre resource
This will enable skinning if the user stores icons within a folder like:
...\AppData\Roaming\calibre\resources\images\Plugin Name\
"""
icon_path = os.path.join(config_dir, 'resources', 'images', self.name, icon_name)
if not os.path.exists(icon_path):
return get_icons(self.plugin_path, 'images/{0}'.format(icon_name))
pixmap = QPixmap()
pixmap.load(icon_path)
return QIcon(pixmap)
class TagsView(QTreeView): # {{{
refresh_required = pyqtSignal()
tags_marked = pyqtSignal(object)
edit_user_category = pyqtSignal(object)
delete_user_category = pyqtSignal(object)
del_item_from_user_cat = pyqtSignal(object, object, object)
add_item_to_user_cat = pyqtSignal(object, object, object)
add_subcategory = pyqtSignal(object)
tags_list_edit = pyqtSignal(object, object)
saved_search_edit = pyqtSignal(object)
rebuild_saved_searches = pyqtSignal()
author_sort_edit = pyqtSignal(object, object, object, object)
tag_item_renamed = pyqtSignal()
search_item_renamed = pyqtSignal()
drag_drop_finished = pyqtSignal(object)
restriction_error = pyqtSignal()
tag_item_delete = pyqtSignal(object, object, object, object)
def __init__(self, parent=None):
QTreeView.__init__(self, parent=None)
self.setMouseTracking(True)
self.alter_tb = None
self.disable_recounting = False
self.setUniformRowHeights(True)
self.setIconSize(QSize(20, 20))
self.setTabKeyNavigation(True)
self.setAnimated(True)
self.setHeaderHidden(True)
self.setItemDelegate(TagDelegate(self))
self.made_connections = False
self.setAcceptDrops(True)
self.setDragEnabled(True)
self.setDragDropMode(self.DragDrop)
self.setDropIndicatorShown(True)
self.in_drag_drop = False
self.setAutoExpandDelay(500)
self.pane_is_visible = False
self.search_icon = QIcon(I('search.png'))
self.user_category_icon = QIcon(I('tb_folder.png'))
self.delete_icon = QIcon(I('list_remove.png'))
self.rename_icon = QIcon(I('edit-undo.png'))
self._model = TagsModel(self)
self._model.search_item_renamed.connect(self.search_item_renamed)
self._model.refresh_required.connect(self.refresh_required,
type=Qt.QueuedConnection)
self._model.tag_item_renamed.connect(self.tag_item_renamed)
self._model.restriction_error.connect(self.restriction_error)
self._model.user_categories_edited.connect(self.user_categories_edited,
type=Qt.QueuedConnection)
self._model.drag_drop_finished.connect(self.drag_drop_finished)
stylish_tb = '''
QTreeView {
background-color: palette(window);
color: palette(window-text);
border: none;
}
'''
self.setStyleSheet('''
QTreeView::item {
border: 1px solid transparent;
padding-top:0.8ex;
padding-bottom:0.8ex;
}
QTreeView::item:hover {
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #e7effd, stop: 1 #cbdaf1);
border: 1px solid #bfcde4;
border-radius: 6px;
}
''' + ('' if gprefs['tag_browser_old_look'] else stylish_tb))
if gprefs['tag_browser_old_look']:
self.setAlternatingRowColors(True)
# Allowing keyboard focus looks bad in the Qt Fusion style and is useless
# anyway since the enter/spacebar keys do nothing
self.setFocusPolicy(Qt.NoFocus)
@property
def hidden_categories(self):
return self._model.hidden_categories
@property
def db(self):
return self._model.db
@property
def collapse_model(self):
return self._model.collapse_model
def set_pane_is_visible(self, to_what):
pv = self.pane_is_visible
self.pane_is_visible = to_what
if to_what and not pv:
self.recount()
def get_state(self):
state_map = {}
expanded_categories = []
for row, category in enumerate(self._model.category_nodes):
if self.isExpanded(self._model.index(row, 0, QModelIndex())):
expanded_categories.append(category.category_key)
states = [c.tag.state for c in category.child_tags()]
names = [(c.tag.name, c.tag.category) for c in category.child_tags()]
state_map[category.category_key] = dict(izip(names, states))
return expanded_categories, state_map
def reread_collapse_parameters(self):
self._model.reread_collapse_model(self.get_state()[1])
def set_database(self, db, alter_tb):
self._model.set_database(db)
self.alter_tb = alter_tb
self.pane_is_visible = True # because TagsModel.set_database did a recount
self.setModel(self._model)
self.setContextMenuPolicy(Qt.CustomContextMenu)
pop = self.db.CATEGORY_SORTS.index(config['sort_tags_by'])
self.alter_tb.sort_menu.actions()[pop].setChecked(True)
try:
match_pop = self.db.MATCH_TYPE.index(config['match_tags_type'])
except ValueError:
match_pop = 0
self.alter_tb.match_menu.actions()[match_pop].setChecked(True)
if not self.made_connections:
self.clicked.connect(self.toggle)
self.customContextMenuRequested.connect(self.show_context_menu)
self.refresh_required.connect(self.recount, type=Qt.QueuedConnection)
self.alter_tb.sort_menu.triggered.connect(self.sort_changed)
self.alter_tb.match_menu.triggered.connect(self.match_changed)
self.made_connections = True
self.refresh_signal_processed = True
db.add_listener(self.database_changed)
self.expanded.connect(self.item_expanded)
def database_changed(self, event, ids):
if self.refresh_signal_processed:
self.refresh_signal_processed = False
self.refresh_required.emit()
def user_categories_edited(self, user_cats, nkey):
state_map = self.get_state()[1]
self.db.new_api.set_pref('user_categories', user_cats)
self._model.rebuild_node_tree(state_map=state_map)
p = self._model.find_category_node('@'+nkey)
self.show_item_at_path(p)
@property
def match_all(self):
return (self.alter_tb and
self.alter_tb.match_menu.actions()[1].isChecked())
def sort_changed(self, action):
for i, ac in enumerate(self.alter_tb.sort_menu.actions()):
if ac is action:
config.set('sort_tags_by', self.db.CATEGORY_SORTS[i])
self.recount()
break
def match_changed(self, action):
try:
for i, ac in enumerate(self.alter_tb.match_menu.actions()):
if ac is action:
config.set('match_tags_type', self.db.MATCH_TYPE[i])
except:
pass
def mouseMoveEvent(self, event):
dex = self.indexAt(event.pos())
if dex.isValid():
self.setCursor(Qt.PointingHandCursor)
else:
self.unsetCursor()
if not event.buttons() & Qt.LeftButton:
return
if self.in_drag_drop or not dex.isValid():
QTreeView.mouseMoveEvent(self, event)
return
# Must deal with odd case where the node being dragged is 'virtual',
# created to form a hierarchy. We can't really drag this node, but in
# addition we can't allow drag recognition to notice going over some
# other node and grabbing that one. So we set in_drag_drop to prevent
# this from happening, turning it off when the user lifts the button.
self.in_drag_drop = True
if not self._model.flags(dex) & Qt.ItemIsDragEnabled:
QTreeView.mouseMoveEvent(self, event)
return
md = self._model.mimeData([dex])
pixmap = dex.data(DRAG_IMAGE_ROLE).pixmap(self.iconSize())
drag = QDrag(self)
drag.setPixmap(pixmap)
drag.setMimeData(md)
if self._model.is_in_user_category(dex):
drag.exec_(Qt.CopyAction|Qt.MoveAction, Qt.CopyAction)
else:
drag.exec_(Qt.CopyAction)
def mouseReleaseEvent(self, event):
# Swallow everything except leftButton so context menus work correctly
if event.button() == Qt.LeftButton or self.in_drag_drop:
QTreeView.mouseReleaseEvent(self, event)
self.in_drag_drop = False
def mouseDoubleClickEvent(self, event):
# swallow these to avoid toggling and editing at the same time
pass
@property
def search_string(self):
tokens = self._model.tokens()
joiner = ' and ' if self.match_all else ' or '
return joiner.join(tokens)
def toggle(self, index):
self._toggle(index, None)
def _toggle(self, index, set_to):
'''
set_to: if None, advance the state. Otherwise must be one of the values
in TAG_SEARCH_STATES
'''
modifiers = int(QApplication.keyboardModifiers())
exclusive = modifiers not in (Qt.CTRL, Qt.SHIFT)
if self._model.toggle(index, exclusive, set_to=set_to):
self.tags_marked.emit(self.search_string)
def conditional_clear(self, search_string):
if search_string != self.search_string:
self.clear()
def context_menu_handler(self, action=None, category=None,
key=None, index=None, search_state=None,
use_vl=None):
if not action:
return
try:
if action == 'set_icon':
try:
path = choose_files(self, 'choose_category_icon',
_('Change Icon for: %s')%key, filters=[
('Images', ['png', 'gif', 'jpg', 'jpeg'])],
all_files=False, select_only_single_file=True)
if path:
path = path[0]
p = QIcon(path).pixmap(QSize(128, 128))
d = os.path.join(config_dir, 'tb_icons')
if not os.path.exists(d):
os.makedirs(d)
with open(os.path.join(d, 'icon_'+
sanitize_file_name_unicode(key)+'.png'), 'wb') as f:
f.write(pixmap_to_data(p, format='PNG'))
path = os.path.basename(f.name)
self._model.set_custom_category_icon(key, unicode(path))
self.recount()
except:
import traceback
traceback.print_exc()
return
if action == 'clear_icon':
self._model.set_custom_category_icon(key, None)
self.recount()
return
if action == 'edit_item_no_vl':
item = self.model().get_node(index)
item.use_vl = False
self.edit(index)
return
if action == 'edit_item_in_vl':
item = self.model().get_node(index)
item.use_vl = True
self.edit(index)
return
if action == 'delete_item_in_vl':
self.tag_item_delete.emit(key, index.id, index.original_name,
self.model().get_book_ids_to_use())
return
if action == 'delete_item_no_vl':
self.tag_item_delete.emit(key, index.id, index.original_name, None)
return
if action == 'open_editor':
self.tags_list_edit.emit(category, key)
return
if action == 'manage_categories':
self.edit_user_category.emit(category)
return
if action == 'search':
self._toggle(index, set_to=search_state)
return
if action == 'add_to_category':
tag = index.tag
if len(index.children) > 0:
for c in index.all_children():
self.add_item_to_user_cat.emit(category, c.tag.original_name,
c.tag.category)
self.add_item_to_user_cat.emit(category, tag.original_name,
tag.category)
return
if action == 'add_subcategory':
self.add_subcategory.emit(key)
return
if action == 'search_category':
self._toggle(index, set_to=search_state)
return
if action == 'delete_user_category':
self.delete_user_category.emit(key)
return
if action == 'delete_search':
self.model().db.saved_search_delete(key)
self.rebuild_saved_searches.emit()
return
if action == 'delete_item_from_user_category':
tag = index.tag
if len(index.children) > 0:
for c in index.children:
self.del_item_from_user_cat.emit(key, c.tag.original_name,
c.tag.category)
self.del_item_from_user_cat.emit(key, tag.original_name, tag.category)
return
if action == 'manage_searches':
self.saved_search_edit.emit(category)
return
if action == 'edit_author_sort':
self.author_sort_edit.emit(self, index, True, False)
return
if action == 'edit_author_link':
self.author_sort_edit.emit(self, index, False, True)
return
reset_filter_categories = True
if action == 'hide':
self.hidden_categories.add(category)
elif action == 'show':
self.hidden_categories.discard(category)
elif action == 'categorization':
changed = self.collapse_model != category
self._model.collapse_model = category
if changed:
reset_filter_categories = False
gprefs['tags_browser_partition_method'] = category
elif action == 'defaults':
self.hidden_categories.clear()
self.db.new_api.set_pref('tag_browser_hidden_categories', list(self.hidden_categories))
if reset_filter_categories:
self._model.set_categories_filter(None)
self._model.rebuild_node_tree()
except:
return
def show_context_menu(self, point):
def display_name(tag):
if tag.category == 'search':
n = tag.name
if len(n) > 45:
n = n[:45] + '...'
return "'" + n + "'"
return tag.name
index = self.indexAt(point)
self.context_menu = QMenu(self)
if index.isValid():
item = index.data(Qt.UserRole)
tag = None
if item.type == TagTreeItem.TAG:
tag_item = item
tag = item.tag
while item.type != TagTreeItem.CATEGORY:
item = item.parent
if item.type == TagTreeItem.CATEGORY:
if not item.category_key.startswith('@'):
while item.parent != self._model.root_item:
item = item.parent
category = unicode(item.name or '')
key = item.category_key
# Verify that we are working with a field that we know something about
if key not in self.db.field_metadata:
return True
# Did the user click on a leaf node?
if tag:
# If the user right-clicked on an editable item, then offer
# the possibility of renaming that item.
if tag.is_editable:
# Add the 'rename' items
if self.model().get_in_vl():
self.context_menu.addAction(self.rename_icon,
_('Rename %s in virtual library')%display_name(tag),
partial(self.context_menu_handler, action='edit_item_in_vl',
index=index))
self.context_menu.addAction(self.rename_icon,
_('Rename %s')%display_name(tag),
partial(self.context_menu_handler, action='edit_item_no_vl',
index=index))
if key in ('tags', 'series', 'publisher') or \
self._model.db.field_metadata.is_custom_field(key):
if self.model().get_in_vl():
self.context_menu.addAction(self.delete_icon,
_('Delete %s in virtual library')%display_name(tag),
partial(self.context_menu_handler, action='delete_item_in_vl',
key=key, index=tag))
self.context_menu.addAction(self.delete_icon,
_('Delete %s')%display_name(tag),
partial(self.context_menu_handler, action='delete_item_no_vl',
key=key, index=tag))
if key == 'authors':
self.context_menu.addAction(_('Edit sort for %s')%display_name(tag),
partial(self.context_menu_handler,
action='edit_author_sort', index=tag.id))
self.context_menu.addAction(_('Edit link for %s')%display_name(tag),
partial(self.context_menu_handler,
action='edit_author_link', index=tag.id))
# is_editable is also overloaded to mean 'can be added
# to a user category'
m = self.context_menu.addMenu(self.user_category_icon,
_('Add %s to user category')%display_name(tag))
nt = self.model().category_node_tree
def add_node_tree(tree_dict, m, path):
p = path[:]
for k in sorted(tree_dict.keys(), key=sort_key):
p.append(k)
n = k[1:] if k.startswith('@') else k
m.addAction(self.user_category_icon, n,
partial(self.context_menu_handler,
'add_to_category',
category='.'.join(p), index=tag_item))
if len(tree_dict[k]):
tm = m.addMenu(self.user_category_icon,
_('Children of %s')%n)
add_node_tree(tree_dict[k], tm, p)
p.pop()
add_node_tree(nt, m, [])
elif key == 'search' and tag.is_searchable:
self.context_menu.addAction(self.rename_icon,
_('Rename %s')%display_name(tag),
partial(self.context_menu_handler, action='edit_item_no_vl',
index=index))
self.context_menu.addAction(self.delete_icon,
_('Delete search %s')%display_name(tag),
partial(self.context_menu_handler,
action='delete_search', key=tag.original_name))
if key.startswith('@') and not item.is_gst:
self.context_menu.addAction(self.user_category_icon,
_('Remove %(item)s from category %(cat)s')%
dict(item=display_name(tag), cat=item.py_name),
partial(self.context_menu_handler,
action='delete_item_from_user_category',
key=key, index=tag_item))
if tag.is_searchable:
# Add the search for value items. All leaf nodes are searchable
self.context_menu.addAction(self.search_icon,
_('Search for %s')%display_name(tag),
partial(self.context_menu_handler, action='search',
search_state=TAG_SEARCH_STATES['mark_plus'],
index=index))
self.context_menu.addAction(self.search_icon,
_('Search for everything but %s')%display_name(tag),
partial(self.context_menu_handler, action='search',
search_state=TAG_SEARCH_STATES['mark_minus'],
index=index))
self.context_menu.addSeparator()
elif key.startswith('@') and not item.is_gst:
if item.can_be_edited:
self.context_menu.addAction(self.rename_icon,
_('Rename %s')%item.py_name,
partial(self.context_menu_handler, action='edit_item_no_vl',
index=index))
self.context_menu.addAction(self.user_category_icon,
_('Add sub-category to %s')%item.py_name,
partial(self.context_menu_handler,
action='add_subcategory', key=key))
self.context_menu.addAction(self.delete_icon,
_('Delete user category %s')%item.py_name,
partial(self.context_menu_handler,
action='delete_user_category', key=key))
self.context_menu.addSeparator()
# Hide/Show/Restore categories
self.context_menu.addAction(_('Hide category %s') % category,
partial(self.context_menu_handler, action='hide',
category=key))
if self.hidden_categories:
m = self.context_menu.addMenu(_('Show category'))
for col in sorted(self.hidden_categories,
key=lambda x: sort_key(self.db.field_metadata[x]['name'])):
m.addAction(self.db.field_metadata[col]['name'],
partial(self.context_menu_handler, action='show', category=col))
# search by category. Some categories are not searchable, such
# as search and news
if item.tag.is_searchable:
self.context_menu.addAction(self.search_icon,
_('Search for books in category %s')%category,
partial(self.context_menu_handler,
action='search_category',
index=self._model.createIndex(item.row(), 0, item),
search_state=TAG_SEARCH_STATES['mark_plus']))
self.context_menu.addAction(self.search_icon,
_('Search for books not in category %s')%category,
partial(self.context_menu_handler,
action='search_category',
index=self._model.createIndex(item.row(), 0, item),
search_state=TAG_SEARCH_STATES['mark_minus']))
# Offer specific editors for tags/series/publishers/saved searches
self.context_menu.addSeparator()
if key in ['tags', 'publisher', 'series'] or \
(self.db.field_metadata[key]['is_custom'] and
self.db.field_metadata[key]['datatype'] != 'composite'):
self.context_menu.addAction(_('Manage %s')%category,
partial(self.context_menu_handler, action='open_editor',
category=tag.original_name if tag else None,
key=key))
elif key == 'authors':
self.context_menu.addAction(_('Manage %s')%category,
partial(self.context_menu_handler, action='edit_author_sort'))
elif key == 'search':
self.context_menu.addAction(_('Manage Saved Searches'),
partial(self.context_menu_handler, action='manage_searches',
category=tag.name if tag else None))
self.context_menu.addSeparator()
self.context_menu.addAction(_('Change category icon'),
partial(self.context_menu_handler, action='set_icon', key=key))
self.context_menu.addAction(_('Restore default icon'),
partial(self.context_menu_handler, action='clear_icon', key=key))
# Always show the user categories editor
self.context_menu.addSeparator()
if key.startswith('@') and \
key[1:] in self.db.prefs.get('user_categories', {}).keys():
self.context_menu.addAction(_('Manage User Categories'),
partial(self.context_menu_handler, action='manage_categories',
category=key[1:]))
else:
self.context_menu.addAction(_('Manage User Categories'),
partial(self.context_menu_handler, action='manage_categories',
category=None))
if self.hidden_categories:
if not self.context_menu.isEmpty():
self.context_menu.addSeparator()
self.context_menu.addAction(_('Show all categories'),
partial(self.context_menu_handler, action='defaults'))
m = self.context_menu.addMenu(_('Change sub-categorization scheme'))
da = m.addAction(_('Disable'),
partial(self.context_menu_handler, action='categorization', category='disable'))
fla = m.addAction(_('By first letter'),
partial(self.context_menu_handler, action='categorization', category='first letter'))
pa = m.addAction(_('Partition'),
partial(self.context_menu_handler, action='categorization', category='partition'))
if self.collapse_model == 'disable':
da.setCheckable(True)
da.setChecked(True)
elif self.collapse_model == 'first letter':
fla.setCheckable(True)
fla.setChecked(True)
else:
pa.setCheckable(True)
pa.setChecked(True)
if config['sort_tags_by'] != "name":
fla.setEnabled(False)
m.hovered.connect(self.collapse_menu_hovered)
fla.setToolTip(_('First letter is usable only when sorting by name'))
# Apparently one cannot set a tooltip to empty, so use a star and
# deal with it in the hover method
da.setToolTip('*')
pa.setToolTip('*')
if index.isValid() and self.model().rowCount(index) > 0:
self.context_menu.addSeparator()
self.context_menu.addAction(_('E&xpand all children'), partial(self.expand_node_and_descendants, index))
if not self.context_menu.isEmpty():
self.context_menu.popup(self.mapToGlobal(point))
return True
def expand_node_and_descendants(self, index):
if not index.isValid():
return
self.expand(index)
for r in xrange(self.model().rowCount(index)):
self.expand_node_and_descendants(index.child(r, 0))
def collapse_menu_hovered(self, action):
tip = action.toolTip()
if tip == '*':
tip = ''
QToolTip.showText(QCursor.pos(), tip)
def dragMoveEvent(self, event):
QTreeView.dragMoveEvent(self, event)
self.setDropIndicatorShown(False)
index = self.indexAt(event.pos())
if not index.isValid():
return
src_is_tb = event.mimeData().hasFormat('application/calibre+from_tag_browser')
item = index.data(Qt.UserRole)
if item.type == TagTreeItem.ROOT:
return
flags = self._model.flags(index)
if item.type == TagTreeItem.TAG and flags & Qt.ItemIsDropEnabled:
self.setDropIndicatorShown(not src_is_tb)
return
if item.type == TagTreeItem.CATEGORY and not item.is_gst:
fm_dest = self.db.metadata_for_field(item.category_key)
if fm_dest['kind'] == 'user':
if src_is_tb:
if event.dropAction() == Qt.MoveAction:
data = str(event.mimeData().data('application/calibre+from_tag_browser'))
src = cPickle.loads(data)
for s in src:
if s[0] == TagTreeItem.TAG and \
(not s[1].startswith('@') or s[2]):
return
self.setDropIndicatorShown(True)
return
md = event.mimeData()
if hasattr(md, 'column_name'):
fm_src = self.db.metadata_for_field(md.column_name)
if md.column_name in ['authors', 'publisher', 'series'] or \
(fm_src['is_custom'] and (
(fm_src['datatype'] in ['series', 'text', 'enumeration'] and
not fm_src['is_multiple']) or
(fm_src['datatype'] == 'composite' and
fm_src['display'].get('make_category', False)))):
self.setDropIndicatorShown(True)
def clear(self):
if self.model():
self.model().clear_state()
def is_visible(self, idx):
item = idx.data(Qt.UserRole)
if getattr(item, 'type', None) == TagTreeItem.TAG:
idx = idx.parent()
return self.isExpanded(idx)
def recount(self, *args):
'''
Rebuild the category tree, expand any categories that were expanded,
reset the search states, and reselect the current node.
'''
if self.disable_recounting or not self.pane_is_visible:
return
self.refresh_signal_processed = True
ci = self.currentIndex()
if not ci.isValid():
ci = self.indexAt(QPoint(10, 10))
path = self.model().path_for_index(ci) if self.is_visible(ci) else None
expanded_categories, state_map = self.get_state()
self._model.rebuild_node_tree(state_map=state_map)
self.blockSignals(True)
for category in expanded_categories:
idx = self._model.index_for_category(category)
if idx is not None and idx.isValid():
self.expand(idx)
self.show_item_at_path(path)
self.blockSignals(False)
def show_item_at_path(self, path, box=False,
position=QTreeView.PositionAtCenter):
'''
Scroll the browser and open categories to show the item referenced by
path. If possible, the item is placed in the center. If box=True, a
box is drawn around the item.
'''
if path:
self.show_item_at_index(self._model.index_for_path(path), box=box,
position=position)
def expand_parent(self, idx):
# Needed otherwise Qt sometimes segfaults if the node is buried in a
# collapsed, off screen hierarchy. To be safe, we expand from the
# outermost in
p = self._model.parent(idx)
if p.isValid():
self.expand_parent(p)
self.expand(idx)
def show_item_at_index(self, idx, box=False,
position=QTreeView.PositionAtCenter):
if idx.isValid() and idx.data(Qt.UserRole) is not self._model.root_item:
self.expand_parent(idx)
self.setCurrentIndex(idx)
self.scrollTo(idx, position)
if box:
self._model.set_boxed(idx)
def item_expanded(self, idx):
'''
Called by the expanded signal
'''
self.setCurrentIndex(idx)
class EmbedComicMetadata(InterfaceAction):
name = 'Embed Comic Metadata'
# Declare the main action associated with this plugin
if prefs["main_import"]:
action_spec = (_L['Import Comic Metadata'], None,
_L['Imports the metadata from the comic to calibre'], None)
else:
action_spec = (_L['Embed Comic Metadata'], None,
_L['Embeds calibres metadata into the comic'], None)
def genesis(self):
# menu
self.menu = QMenu(self.gui)
# Set the icon for this interface action
icon = get_icons('images/icon.png') # need to import this?
# The qaction is automatically created from the action_spec defined
# above
self.qaction.setMenu(self.menu)
self.qaction.setIcon(icon)
self.qaction.triggered.connect(self.main_menu_triggered)
# build menu
self.menu.clear()
self.build_menu()
self.toggle_menu_items()
def build_menu(self):
for item in config[CONFIG_MENU]["UI_Action_Items"]:
if item[CONFIG_NAME] == "seperator":
self.menu.addSeparator()
continue
elif item[CONFIG_TRIGGER_ARG]:
triggerfunc = partial(item[CONFIG_TRIGGER_FUNC], self, item[CONFIG_TRIGGER_ARG])
else:
triggerfunc = partial(item[CONFIG_TRIGGER_FUNC], self)
self.menu_action(item[CONFIG_NAME], item[CONFIG_DESCRIPTION], triggerfunc)
# add configuration entry
self.menu_action("configure", _L["Configure"],
partial(self.interface_action_base_plugin.do_user_config, (self.gui)))
def toggle_menu_items(self):
for item in config[CONFIG_MENU]["Items"]:
action = getattr(self, item[CONFIG_NAME])
action.setVisible(prefs[item[CONFIG_NAME]])
def main_menu_triggered(self):
from calibre_plugins.EmbedComicMetadata.main import embed_into_comic, import_to_calibre
# Check the preferences for what should be done
if (prefs['read_cbi'] and prefs['read_cix']) or (prefs['cbi_embed'] and prefs['cix_embed']):
action = "both"
elif (prefs['read_cbi']) or (prefs['cbi_embed']):
action = "cbi"
elif (prefs['read_cix']) or (prefs['cix_embed']):
action = "cix"
else:
return error_dialog(self.gui, _L['Cannot update metadata'],
_L['No embed format selected'], show=True)
if prefs["main_import"]:
import_to_calibre(self, action)
else:
embed_into_comic(self, action)
def apply_settings(self):
from calibre_plugins.EmbedComicMetadata.config import prefs
# In an actual non trivial plugin, you would probably need to
# do something based on the settings in prefs
prefs
def menu_action(self, name, title, triggerfunc):
action = self.create_menu_action(self.menu, name, title, icon=None,
shortcut=None, description=None, triggered=triggerfunc,
shortcut_name=None)
setattr(self, name, action)
class LocationManager(QObject): # {{{
locations_changed = pyqtSignal()
unmount_device = pyqtSignal()
location_selected = pyqtSignal(object)
configure_device = pyqtSignal()
update_device_metadata = pyqtSignal()
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.free = [-1, -1, -1]
self.count = 0
self.location_actions = QActionGroup(self)
self.location_actions.setExclusive(True)
self.current_location = 'library'
self._mem = []
self.tooltips = {}
self.all_actions = []
def ac(name, text, icon, tooltip):
icon = QIcon(I(icon))
ac = self.location_actions.addAction(icon, text)
setattr(self, 'location_'+name, ac)
ac.setAutoRepeat(False)
ac.setCheckable(True)
receiver = partial(self._location_selected, name)
ac.triggered.connect(receiver)
self.tooltips[name] = tooltip
m = QMenu(parent)
self._mem.append(m)
a = m.addAction(icon, tooltip)
a.triggered.connect(receiver)
if name != 'library':
self._mem.append(a)
a = m.addAction(QIcon(I('eject.png')), _('Eject this device'))
a.triggered.connect(self._eject_requested)
self._mem.append(a)
a = m.addAction(QIcon(I('config.png')), _('Configure this device'))
a.triggered.connect(self._configure_requested)
self._mem.append(a)
a = m.addAction(QIcon(I('sync.png')), _('Update cached metadata on device'))
a.triggered.connect(lambda x : self.update_device_metadata.emit())
self._mem.append(a)
else:
ac.setToolTip(tooltip)
ac.setMenu(m)
ac.calibre_name = name
self.all_actions.append(ac)
return ac
self.library_action = ac('library', _('Library'), 'lt.png',
_('Show books in calibre library'))
ac('main', _('Device'), 'reader.png',
_('Show books in the main memory of the device'))
ac('carda', _('Card A'), 'sd.png',
_('Show books in storage card A'))
ac('cardb', _('Card B'), 'sd.png',
_('Show books in storage card B'))
def set_switch_actions(self, quick_actions, rename_actions, delete_actions,
switch_actions, choose_action):
self.switch_menu = self.library_action.menu()
if self.switch_menu:
self.switch_menu.addSeparator()
else:
self.switch_menu = QMenu()
self.switch_menu.addAction(choose_action)
self.cs_menus = []
for t, acs in [(_('Quick switch'), quick_actions),
(_('Rename library'), rename_actions),
(_('Delete library'), delete_actions)]:
if acs:
self.cs_menus.append(QMenu(t))
for ac in acs:
self.cs_menus[-1].addAction(ac)
self.switch_menu.addMenu(self.cs_menus[-1])
self.switch_menu.addSeparator()
for ac in switch_actions:
self.switch_menu.addAction(ac)
if self.switch_menu != self.library_action.menu():
self.library_action.setMenu(self.switch_menu)
def _location_selected(self, location, *args):
if location != self.current_location and hasattr(self,
'location_'+location):
self.current_location = location
self.location_selected.emit(location)
getattr(self, 'location_'+location).setChecked(True)
def _eject_requested(self, *args):
self.unmount_device.emit()
def _configure_requested(self):
self.configure_device.emit()
def update_devices(self, cp=(None, None), fs=[-1, -1, -1], icon=None):
if icon is None:
icon = I('reader.png')
self.location_main.setIcon(QIcon(icon))
had_device = self.has_device
if cp is None:
cp = (None, None)
if isinstance(cp, (str, unicode)):
cp = (cp, None)
if len(fs) < 3:
fs = list(fs) + [0]
self.free[0] = fs[0]
self.free[1] = fs[1]
self.free[2] = fs[2]
cpa, cpb = cp
self.free[1] = fs[1] if fs[1] is not None and cpa is not None else -1
self.free[2] = fs[2] if fs[2] is not None and cpb is not None else -1
self.update_tooltips()
if self.has_device != had_device:
self.location_library.setChecked(True)
self.locations_changed.emit()
if not self.has_device:
self.location_library.trigger()
def update_tooltips(self):
for i, loc in enumerate(('main', 'carda', 'cardb')):
t = self.tooltips[loc]
if self.free[i] > -1:
t += u'\n\n%s '%human_readable(self.free[i]) + _('available')
ac = getattr(self, 'location_'+loc)
ac.setToolTip(t)
ac.setWhatsThis(t)
ac.setStatusTip(t)
@property
def has_device(self):
return max(self.free) > -1
@property
def available_actions(self):
ans = [self.location_library]
for i, loc in enumerate(('main', 'carda', 'cardb')):
if self.free[i] > -1:
ans.append(getattr(self, 'location_'+loc))
return ans
def show_context_menu(self, pos):
m = QMenu(self)
a = m.addAction
c = self.editor.cursorForPosition(pos)
origc = QTextCursor(c)
current_cursor = self.editor.textCursor()
r = origr = self.editor.syntax_range_for_cursor(c)
if (
r is None or not r.format.property(SPELL_PROPERTY)
) and c.positionInBlock() > 0 and not current_cursor.hasSelection():
c.setPosition(c.position() - 1)
r = self.editor.syntax_range_for_cursor(c)
if r is not None and r.format.property(SPELL_PROPERTY):
word = self.editor.text_for_range(c.block(), r)
locale = self.editor.spellcheck_locale_for_cursor(c)
orig_pos = c.position()
c.setPosition(orig_pos - utf16_length(word))
found = False
self.editor.setTextCursor(c)
if self.editor.find_spell_word([word],
locale.langcode,
center_on_cursor=False):
found = True
fc = self.editor.textCursor()
if fc.position() < c.position():
self.editor.find_spell_word([word],
locale.langcode,
center_on_cursor=False)
spell_cursor = self.editor.textCursor()
if current_cursor.hasSelection():
# Restore the current cursor so that any selection is preserved
# for the change case actions
self.editor.setTextCursor(current_cursor)
if found:
suggestions = dictionaries.suggestions(word, locale)[:7]
if suggestions:
for suggestion in suggestions:
ac = m.addAction(
suggestion,
partial(self.editor.simple_replace,
suggestion,
cursor=spell_cursor))
f = ac.font()
f.setBold(True), ac.setFont(f)
m.addSeparator()
m.addAction(actions['spell-next'])
m.addAction(_('Ignore this word'),
partial(self._nuke_word, None, word, locale))
dics = dictionaries.active_user_dictionaries
if len(dics) > 0:
if len(dics) == 1:
m.addAction(
_('Add this word to the dictionary: {0}').format(
dics[0].name),
partial(self._nuke_word, dics[0].name, word,
locale))
else:
ac = m.addAction(_('Add this word to the dictionary'))
dmenu = QMenu(m)
ac.setMenu(dmenu)
for dic in dics:
dmenu.addAction(
dic.name,
partial(self._nuke_word, dic.name, word,
locale))
m.addSeparator()
if origr is not None and origr.format.property(LINK_PROPERTY):
href = self.editor.text_for_range(origc.block(), origr)
m.addAction(
_('Open %s') % href, partial(self.link_clicked.emit, href))
if origr is not None and (origr.format.property(TAG_NAME_PROPERTY)
or origr.format.property(CSS_PROPERTY)):
word = self.editor.text_for_range(origc.block(), origr)
item_type = 'tag_name' if origr.format.property(
TAG_NAME_PROPERTY) else 'css_property'
url = help_url(word,
item_type,
self.editor.highlighter.doc_name,
extra_data=current_container().opf_version)
if url is not None:
m.addAction(
_('Show help for: %s') % word, partial(open_url, url))
for x in ('undo', 'redo'):
ac = actions['editor-%s' % x]
if ac.isEnabled():
a(ac)
m.addSeparator()
for x in ('cut', 'copy', 'paste'):
ac = actions['editor-' + x]
if ac.isEnabled():
a(ac)
m.addSeparator()
m.addAction(_('&Select all'), self.editor.select_all)
if self.selected_text or self.has_marked_text:
update_mark_text_action(self)
m.addAction(actions['mark-selected-text'])
if self.syntax != 'css' and actions['editor-cut'].isEnabled():
cm = QMenu(_('Change &case'), m)
for ac in 'upper lower swap title capitalize'.split():
cm.addAction(actions['transform-case-' + ac])
m.addMenu(cm)
if self.syntax == 'html':
m.addAction(actions['multisplit'])
m.exec_(self.editor.viewport().mapToGlobal(pos))
class EKWindow(QDialog):
"""
Class which is responisble for running this entire application
"""
def __init__(self):
"""
Constructor for this class
"""
super(EKWindow, self).__init__()
self.engine = Engine("tables/Tamil-bamini.txt.in")
# Settings file initialization
self.settingsFilePath = os.getenv("APPDATA") + "\\" + qApp.applicationName() + "\eksettings.ini"
self.init_settings() # Function to check whether the settings file is or not.
self.iniSettings = QSettings(self.settingsFilePath, QSettings.IniFormat)
# Variable Initialization
self.registrySettings = QSettings("HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run", QSettings.NativeFormat)
self.shortcutModifierKey = self.iniSettings.value("shortcut_modifier")
self.shortcutKey = self.iniSettings.value("shortcut")
self.selectedKeyboard = self.iniSettings.value("selected_keyboard")
self.keyboardStatus = False
self.fileName = ""
# Ui variable Initialization
self.iconGroupBox = QGroupBox("Keyboards")
self.iconLabel = QLabel("Keyboard:")
self.iconComboBox = QComboBox(self)
self.shortcutGroupBox = QGroupBox("Shortcut Setting")
self.shortcutComboBox1 = QComboBox(self)
self.shortcutComboBox2 = QComboBox(self)
self.otherSettingsGroupBox = QGroupBox("Other Settings")
self.checkboxStartWithWindows = QCheckBox()
self.minimizeAction = QAction("Minimize", self)
self.maximizeAction = QAction("Maximize", self)
self.settingsAction = QAction("Settings", self)
self.aboutAction = QAction("About", self)
self.quitAction = QAction("Quit", self)
self.trayIconMenu = QMenu(self)
self.trayIcon = QSystemTrayIcon(self)
self.mainLayout = QVBoxLayout()
self.mainLayout.addWidget(self.iconGroupBox)
self.mainLayout.addWidget(self.shortcutGroupBox)
self.mainLayout.addWidget(self.otherSettingsGroupBox)
self.setLayout(self.mainLayout)
# UI constructor and connectors
self.create_settings_group_boxes()
self.create_actions()
self.create_tray_icon()
# Signal connectors
self.iconComboBox.currentIndexChanged.connect(self.change_keyboard)
self.shortcutComboBox1.currentIndexChanged.connect(self.set_shortcut_modifier)
self.shortcutComboBox2.currentIndexChanged.connect(self.set_shortcut_key)
self.trayIcon.activated.connect(self.icon_activated)
self.checkboxStartWithWindows.stateChanged.connect(self.checkbox_start_with_windows_ticked)
if self.keyboardStatus:
self.iconComboBox.setCurrentIndex(self.selectedKeyBoard)
else:
self.change_keyboard(0)
self.iconComboBox.setCurrentIndex(0)
self.trayIcon.show()
self.set_shortcut_key()
self.setWindowTitle(qApp.applicationName() + " " + qApp.applicationVersion())
def init_settings(self):
"""
Function to check whether the settings file is there or not. If there is no file, then it will create with
default settings.
"""
if not os.path.exists(self.settingsFilePath):
settings_dir = os.getenv("APPDATA") + "\\" + qApp.applicationName()
if not os.path.exists(settings_dir):
os.makedirs(settings_dir)
setting_path = ""
if getattr(sys, 'frozen', False):
setting_path = os.path.dirname(sys.executable)
elif __file__:
setting_path = os.path.dirname(__file__)
shutil.copyfile(os.path.join(setting_path, "resources\eksettings.ini"), self.settingsFilePath)
return
def create_settings_group_boxes(self):
"""
UI generator function.
"""
self.iconComboBox.addItem("No Keyboard")
self.iconComboBox.addItem("Tamil99")
self.iconComboBox.addItem("Phonetic")
self.iconComboBox.addItem("Typewriter")
self.iconComboBox.addItem("Bamini")
self.iconComboBox.addItem("Inscript")
icon_layout = QHBoxLayout(self)
icon_layout.addWidget(self.iconLabel)
icon_layout.addWidget(self.iconComboBox)
icon_layout.addStretch()
self.iconGroupBox.setLayout(icon_layout)
shortcut_label_1 = QLabel("Modifier Key:")
shortcut_label_2 = QLabel("Shortcut Key:")
self.shortcutComboBox1.addItem("NONE")
self.shortcutComboBox1.addItem("CTRL")
self.shortcutComboBox1.addItem("ALT")
modifier_index = self.shortcutComboBox1.findText(self.shortcutModifierKey)
self.shortcutComboBox1.setCurrentIndex(modifier_index)
self.shortcutComboBox2.setMinimumContentsLength(3)
if modifier_index == 0:
self.shortcutComboBox2.addItem("F1")
self.shortcutComboBox2.addItem("ESC")
self.shortcutComboBox2.addItem("F2")
self.shortcutComboBox2.addItem("F3")
self.shortcutComboBox2.addItem("F4")
self.shortcutComboBox2.addItem("F5")
self.shortcutComboBox2.addItem("F6")
self.shortcutComboBox2.addItem("F7")
self.shortcutComboBox2.addItem("F8")
self.shortcutComboBox2.addItem("F9")
self.shortcutComboBox2.addItem("F10")
else:
self.shortcutComboBox2.addItem("1")
self.shortcutComboBox2.addItem("2")
self.shortcutComboBox2.addItem("3")
self.shortcutComboBox2.addItem("4")
self.shortcutComboBox2.addItem("5")
self.shortcutComboBox2.addItem("6")
self.shortcutComboBox2.addItem("7")
self.shortcutComboBox2.addItem("8")
self.shortcutComboBox2.addItem("9")
self.shortcutComboBox2.addItem("0")
key_index = self.shortcutComboBox2.findText(self.shortcutKey)
self.shortcutComboBox2.setCurrentIndex(key_index)
shortcut_layout = QHBoxLayout(self)
shortcut_layout.addWidget(shortcut_label_1)
shortcut_layout.addWidget(self.shortcutComboBox1)
shortcut_layout.addWidget(shortcut_label_2)
shortcut_layout.addWidget(self.shortcutComboBox2)
shortcut_layout.addStretch()
self.shortcutGroupBox.setLayout(shortcut_layout)
checkbox_start_with_windows_label = QLabel("Start eKalappai whenever windows starts")
# if registry entry for auto start with windows for the current user exists, then check the checkbox
if self.registrySettings.contains(qApp.applicationName()):
self.checkboxStartWithWindows.setChecked(True)
else:
self.checkboxStartWithWindows.setChecked(False)
other_settings_layout = QHBoxLayout(self)
other_settings_layout.addWidget(checkbox_start_with_windows_label)
other_settings_layout.addWidget(self.checkboxStartWithWindows)
other_settings_layout.addStretch()
self.otherSettingsGroupBox.setLayout(other_settings_layout)
def set_shortcut_key(self):
"""
Function to change the shortcut key when its changed.
"""
self.shortcutKey = self.shortcutComboBox2.currentText()
self.iniSettings.setValue("shortcut", self.shortcutKey)
self.register_shortcut_listener()
if self.shortcutKey == "ESC":
self.shortcutKeyHex = 0x1B
elif self.shortcutKey == "F1":
self.shortcutKeyHex = 0x70
elif self.shortcutKey == "F2":
self.shortcutKeyHex = 0x71
elif self.shortcutKey == "F3":
self.shortcutKeyHex = 0x72
elif self.shortcutKey == "F4":
self.shortcutKeyHex = 0x73
elif self.shortcutKey == "F5":
self.shortcutKeyHex = 0x74
elif self.shortcutKey == "F6":
self.shortcutKeyHex = 0x75
elif self.shortcutKey == "F7":
self.shortcutKeyHex = 0x76
elif self.shortcutKey == "F8":
self.shortcutKeyHex = 0x77
elif self.shortcutKey == "F9":
self.shortcutKeyHex = 0x78
elif self.shortcutKey == "F10":
self.shortcutKeyHex = 0x79
elif self.shortcutKey == "1":
self.shortcutKeyHex = 0x31
elif self.shortcutKey == "2":
self.shortcutKeyHex = 0x32
elif self.shortcutKey == "3":
self.shortcutKeyHex = 0x33
elif self.shortcutKey == "4":
self.shortcutKeyHex = 0x34
elif self.shortcutKey == "5":
self.shortcutKeyHex = 0x35
elif self.shortcutKey == "6":
self.shortcutKeyHex = 0x36
elif self.shortcutKey == "7":
self.shortcutKeyHex = 0x37
elif self.shortcutKey == "8":
self.shortcutKeyHex = 0x38
elif self.shortcutKey == "9":
self.shortcutKeyHex = 0x39
elif self.shortcutKey == "0":
self.shortcutKeyHex = 0x30
def create_actions(self):
"""
Slot connectors for all right clicking and other actions.
"""
self.minimizeAction.triggered.connect(self.hide)
self.maximizeAction.triggered.connect(self.showMaximized)
self.settingsAction.triggered.connect(self.showNormal)
self.aboutAction.triggered.connect(self.show_about)
self.quitAction.triggered.connect(self.quit)
def quit(self):
self.engine.un_hook()
exit(0)
def create_tray_icon(self):
"""
Tray icon creator and corresponding connectors
"""
self.trayIconMenu.addAction(self.settingsAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.aboutAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.quitAction)
self.trayIcon.setContextMenu(self.trayIconMenu)
def setVisible(self, visible):
self.settingsAction.setEnabled(self.isMaximized() or not visible)
super(EKWindow, self).setVisible(visible)
def closeEvent(self, event):
if self.trayIcon.isVisible():
self.hide()
event.ignore()
def load_keyboard(self):
"""
Mapping file loading function
"""
if self.selectedKeyboard == 1:
self.fileName = "tables/Tamil-tamil99.txt.in"
elif self.selectedKeyboard == 2:
self.fileName = "tables/Tamil-phonetic.txt.in"
elif self.selectedKeyboard == 3:
self.fileName = "tables/Tamil-typewriter.txt.in"
elif self.selectedKeyboard == 4:
self.fileName = "tables/Tamil-bamini.txt.in"
elif self.selectedKeyboard == 5:
self.fileName = "tables/Tamil-inscript.txt.in"
else:
pass
def getPath(self, index):
if index == 1:
self.path = "tables/Tamil-tamil99.txt.in"
elif index == 2:
self.path = "tables/Tamil-phonetic.txt.in"
elif index == 3:
self.path = "tables/Tamil-typewriter.txt.in"
elif index == 4:
self.path = "tables/Tamil-bamini.txt.in"
elif index == 5:
self.path = "tables/Tamil-inscript.txt.in"
else:
pass
def change_keyboard(self, index):
"""
Function to change the keyboard based on the index which was sent as a param
"""
if int(index) != 0:
self.iniSettings.setValue("selected_keyboard", index)
self.selectedKeyboard = index
self.iconComboBox.setCurrentIndex(int(index))
icon = self.iconComboBox.itemIcon(int(index))
self.trayIcon.setIcon(icon)
self.setWindowIcon(icon)
self.trayIcon.setToolTip(self.iconComboBox.itemText(int(index)))
self.show_tray_message(index)
self.load_keyboard()
if int(index) != 0:
self.getPath(int(index))
self.engine.file_name = self.path
self.engine.initialize()
self.engine.conv_state = True
else:
try:
self.engine.conv_state = False
except:
pass
def icon_activated(self, reason):
"""
Function to toggle the state when the icon is clicked or shortcut key is pressed
"""
if reason == QSystemTrayIcon.DoubleClick:
pass
elif reason == QSystemTrayIcon.Trigger:
if self.keyboardStatus:
self.keyboardStatus = False
else:
self.keyboardStatus = True
if self.keyboardStatus:
self.change_keyboard(self.selectedKeyboard)
else:
self.change_keyboard(0)
elif reason == QSystemTrayIcon.MiddleClick:
pass
else:
pass
def show_tray_message(self, index):
"""
Tray message generator when there is change in keyboard state
"""
icon = QSystemTrayIcon.MessageIcon(0)
message = self.iconComboBox.itemText(int(index)) + " set"
self.trayIcon.showMessage(qApp.applicationName() + " " + qApp.applicationVersion(), message, icon, 100)
def checkbox_start_with_windows_ticked(self):
"""
Function to add or disable registry entry to auto start ekalappai with windows for the current users
"""
if self.checkboxStartWithWindows.isChecked():
self.registrySettings.setValue(qApp.applicationName(), qApp.applicationFilePath())
else:
self.registrySettings.remove(qApp.applicationName())
def show_about(self):
pass
def set_shortcut_modifier(self, index):
"""
Function to set the shortcut modifier when its changed.
"""
self.iniSettings.setValue("shortcut_modifier", self.shortcutComboBox1.currentText())
self.shortcutModifierKey = self.iniSettings.value("shortcut_modifier")
# if none is selected, the allowed single key shortcuts should change
if index == 0:
self.shortcutComboBox2.clear()
self.shortcutComboBox2.addItem("ESC")
self.shortcutComboBox2.addItem("F1")
self.shortcutComboBox2.addItem("F2")
self.shortcutComboBox2.addItem("F3")
self.shortcutComboBox2.addItem("F4")
self.shortcutComboBox2.addItem("F5")
self.shortcutComboBox2.addItem("F6")
self.shortcutComboBox2.addItem("F7")
self.shortcutComboBox2.addItem("F8")
self.shortcutComboBox2.addItem("F9")
self.shortcutComboBox2.addItem("F10")
else:
self.shortcutComboBox2.clear()
self.shortcutComboBox2.addItem("1")
self.shortcutComboBox2.addItem("2")
self.shortcutComboBox2.addItem("3")
self.shortcutComboBox2.addItem("4")
self.shortcutComboBox2.addItem("5")
self.shortcutComboBox2.addItem("6")
self.shortcutComboBox2.addItem("7")
self.shortcutComboBox2.addItem("8")
self.shortcutComboBox2.addItem("9")
self.shortcutComboBox2.addItem("0")
self.register_shortcut_listener()
def register_shortcut_listener(self):
self.engine.event_queue.remove_all()
if self.iniSettings.value("shortcut_modifier") == "NONE":
self.engine.event_queue.register_event([[self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
elif self.iniSettings.value("shortcut_modifier") == "CTRL":
self.engine.event_queue.register_event([['Lcontrol', self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
self.engine.event_queue.register_event([['Rcontrol', self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
elif self.iniSettings.value("shortcut_modifier") == "ALT":
self.engine.event_queue.register_event([['LMenu', self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
self.engine.event_queue.register_event([['RMenu', self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
return True
class BooksView(QTableView): # {{{
files_dropped = pyqtSignal(object)
add_column_signal = pyqtSignal()
is_library_view = True
def viewportEvent(self, event):
if (event.type() == event.ToolTip and not gprefs['book_list_tooltips']):
return False
return QTableView.viewportEvent(self, event)
def __init__(self, parent, modelcls=BooksModel, use_edit_metadata_dialog=True):
QTableView.__init__(self, parent)
self.default_row_height = self.verticalHeader().defaultSectionSize()
self.gui = parent
self.setProperty('highlight_current_item', 150)
self.row_sizing_done = False
self.alternate_views = AlternateViews(self)
if not tweaks['horizontal_scrolling_per_column']:
self.setHorizontalScrollMode(self.ScrollPerPixel)
self.setEditTriggers(self.EditKeyPressed)
if tweaks['doubleclick_on_library_view'] == 'edit_cell':
self.setEditTriggers(self.DoubleClicked|self.editTriggers())
elif tweaks['doubleclick_on_library_view'] == 'open_viewer':
self.setEditTriggers(self.SelectedClicked|self.editTriggers())
self.doubleClicked.connect(parent.iactions['View'].view_triggered)
elif tweaks['doubleclick_on_library_view'] == 'edit_metadata':
# Must not enable single-click to edit, or the field will remain
# open in edit mode underneath the edit metadata dialog
if use_edit_metadata_dialog:
self.doubleClicked.connect(
partial(parent.iactions['Edit Metadata'].edit_metadata,
checked=False))
else:
self.setEditTriggers(self.DoubleClicked|self.editTriggers())
setup_dnd_interface(self)
self.setAlternatingRowColors(True)
self.setShowGrid(False)
self.setWordWrap(False)
self.rating_delegate = RatingDelegate(self)
self.timestamp_delegate = DateDelegate(self)
self.pubdate_delegate = PubDateDelegate(self)
self.last_modified_delegate = DateDelegate(self,
tweak_name='gui_last_modified_display_format')
self.languages_delegate = LanguagesDelegate(self)
self.tags_delegate = CompleteDelegate(self, ',', 'all_tag_names')
self.authors_delegate = CompleteDelegate(self, '&', 'all_author_names', True)
self.cc_names_delegate = CompleteDelegate(self, '&', 'all_custom', True)
self.series_delegate = TextDelegate(self)
self.publisher_delegate = TextDelegate(self)
self.text_delegate = TextDelegate(self)
self.cc_text_delegate = CcTextDelegate(self)
self.cc_enum_delegate = CcEnumDelegate(self)
self.cc_bool_delegate = CcBoolDelegate(self)
self.cc_comments_delegate = CcCommentsDelegate(self)
self.cc_template_delegate = CcTemplateDelegate(self)
self.cc_number_delegate = CcNumberDelegate(self)
self.display_parent = parent
self._model = modelcls(self)
self.setModel(self._model)
self._model.count_changed_signal.connect(self.do_row_sizing,
type=Qt.QueuedConnection)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setSortingEnabled(True)
self.selectionModel().currentRowChanged.connect(self._model.current_changed)
self.preserve_state = partial(PreserveViewState, self)
self.marked_changed_listener = FunctionDispatcher(self.marked_changed)
# {{{ Column Header setup
self.can_add_columns = True
self.was_restored = False
self.column_header = HeaderView(Qt.Horizontal, self)
self.setHorizontalHeader(self.column_header)
self.column_header.sortIndicatorChanged.disconnect()
self.column_header.sortIndicatorChanged.connect(self.user_sort_requested)
self.column_header.setSectionsMovable(True)
self.column_header.setSectionsClickable(True)
self.column_header.sectionMoved.connect(self.save_state)
self.column_header.setContextMenuPolicy(Qt.CustomContextMenu)
self.column_header.customContextMenuRequested.connect(self.show_column_header_context_menu)
self.column_header.sectionResized.connect(self.column_resized, Qt.QueuedConnection)
self.row_header = HeaderView(Qt.Vertical, self)
self.row_header.setSectionResizeMode(self.row_header.Fixed)
self.setVerticalHeader(self.row_header)
# }}}
self._model.database_changed.connect(self.database_changed)
hv = self.verticalHeader()
hv.setSectionsClickable(True)
hv.setCursor(Qt.PointingHandCursor)
self.selected_ids = []
self._model.about_to_be_sorted.connect(self.about_to_be_sorted)
self._model.sorting_done.connect(self.sorting_done,
type=Qt.QueuedConnection)
# Column Header Context Menu {{{
def column_header_context_handler(self, action=None, column=None):
if not action or not column:
return
try:
idx = self.column_map.index(column)
except:
return
h = self.column_header
if action == 'hide':
if h.hiddenSectionCount() >= h.count():
return error_dialog(self, _('Cannot hide all columns'), _(
'You must not hide all columns'), show=True)
h.setSectionHidden(idx, True)
elif action == 'show':
h.setSectionHidden(idx, False)
if h.sectionSize(idx) < 3:
sz = h.sectionSizeHint(idx)
h.resizeSection(idx, sz)
elif action == 'ascending':
self.sort_by_column_and_order(idx, True)
elif action == 'descending':
self.sort_by_column_and_order(idx, False)
elif action == 'defaults':
self.apply_state(self.get_default_state())
elif action == 'addcustcol':
self.add_column_signal.emit()
elif action.startswith('align_'):
alignment = action.partition('_')[-1]
self._model.change_alignment(column, alignment)
elif action == 'quickview':
from calibre.customize.ui import find_plugin
qv = find_plugin('Show Quickview')
if qv:
rows = self.selectionModel().selectedRows()
if len(rows) > 0:
current_row = rows[0].row()
current_col = self.column_map.index(column)
index = self.model().index(current_row, current_col)
qv.actual_plugin_.change_quickview_column(index)
self.save_state()
def show_column_header_context_menu(self, pos):
idx = self.column_header.logicalIndexAt(pos)
if idx > -1 and idx < len(self.column_map):
col = self.column_map[idx]
name = unicode(self.model().headerData(idx, Qt.Horizontal,
Qt.DisplayRole) or '')
self.column_header_context_menu = QMenu(self)
if col != 'ondevice':
self.column_header_context_menu.addAction(_('Hide column %s') %
name,
partial(self.column_header_context_handler, action='hide',
column=col))
m = self.column_header_context_menu.addMenu(
_('Sort on %s') % name)
a = m.addAction(_('Ascending'),
partial(self.column_header_context_handler,
action='ascending', column=col))
d = m.addAction(_('Descending'),
partial(self.column_header_context_handler,
action='descending', column=col))
if self._model.sorted_on[0] == col:
ac = a if self._model.sorted_on[1] else d
ac.setCheckable(True)
ac.setChecked(True)
if col not in ('ondevice', 'inlibrary') and \
(not self.model().is_custom_column(col) or
self.model().custom_columns[col]['datatype'] not in ('bool',
)):
m = self.column_header_context_menu.addMenu(
_('Change text alignment for %s') % name)
al = self._model.alignment_map.get(col, 'left')
for x, t in (('left', _('Left')), ('right', _('Right')), ('center',
_('Center'))):
a = m.addAction(t,
partial(self.column_header_context_handler,
action='align_'+x, column=col))
if al == x:
a.setCheckable(True)
a.setChecked(True)
if not isinstance(self, DeviceBooksView):
if self._model.db.field_metadata[col]['is_category']:
act = self.column_header_context_menu.addAction(_('Quickview column %s') %
name,
partial(self.column_header_context_handler, action='quickview',
column=col))
rows = self.selectionModel().selectedRows()
if len(rows) > 1:
act.setEnabled(False)
hidden_cols = [self.column_map[i] for i in
range(self.column_header.count()) if
self.column_header.isSectionHidden(i)]
try:
hidden_cols.remove('ondevice')
except:
pass
if hidden_cols:
self.column_header_context_menu.addSeparator()
m = self.column_header_context_menu.addMenu(_('Show column'))
for col in hidden_cols:
hidx = self.column_map.index(col)
name = unicode(self.model().headerData(hidx, Qt.Horizontal,
Qt.DisplayRole) or '')
m.addAction(name,
partial(self.column_header_context_handler,
action='show', column=col))
self.column_header_context_menu.addSeparator()
self.column_header_context_menu.addAction(
_('Shrink column if it is too wide to fit'),
partial(self.resize_column_to_fit, column=self.column_map[idx]))
self.column_header_context_menu.addAction(
_('Restore default layout'),
partial(self.column_header_context_handler,
action='defaults', column=col))
if self.can_add_columns:
self.column_header_context_menu.addAction(
QIcon(I('column.png')),
_('Add your own columns'),
partial(self.column_header_context_handler,
action='addcustcol', column=col))
self.column_header_context_menu.popup(self.column_header.mapToGlobal(pos))
# }}}
# Sorting {{{
def sort_by_column_and_order(self, col, ascending):
self.column_header.blockSignals(True)
self.sortByColumn(col, Qt.AscendingOrder if ascending else Qt.DescendingOrder)
self.column_header.blockSignals(False)
def user_sort_requested(self, col, order=Qt.AscendingOrder):
if col >= len(self.column_map) or col < 0:
return QTableView.sortByColumn(self, col)
field = self.column_map[col]
self.intelligent_sort(field, order == Qt.AscendingOrder)
def intelligent_sort(self, field, ascending):
m = self.model()
pname = 'previous_sort_order_' + self.__class__.__name__
previous = gprefs.get(pname, {})
if field == m.sorted_on[0] or field not in previous:
self.sort_by_named_field(field, ascending)
previous[field] = ascending
gprefs[pname] = previous
return
previous[m.sorted_on[0]] = m.sorted_on[1]
gprefs[pname] = previous
self.sort_by_named_field(field, previous[field])
def about_to_be_sorted(self, idc):
selected_rows = [r.row() for r in self.selectionModel().selectedRows()]
self.selected_ids = [idc(r) for r in selected_rows]
def sorting_done(self, indexc):
pos = self.horizontalScrollBar().value()
self.select_rows(self.selected_ids, using_ids=True, change_current=True,
scroll=True)
self.selected_ids = []
self.horizontalScrollBar().setValue(pos)
def sort_by_named_field(self, field, order, reset=True):
if field in self.column_map:
idx = self.column_map.index(field)
self.sort_by_column_and_order(idx, order)
else:
self._model.sort_by_named_field(field, order, reset)
self.column_header.blockSignals(True)
self.column_header.setSortIndicator(-1, Qt.AscendingOrder)
self.column_header.blockSignals(False)
def multisort(self, fields, reset=True, only_if_different=False):
if len(fields) == 0:
return
sh = self.cleanup_sort_history(self._model.sort_history,
ignore_column_map=True)
if only_if_different and len(sh) >= len(fields):
ret=True
for i,t in enumerate(fields):
if t[0] != sh[i][0]:
ret = False
break
if ret:
return
for n,d in reversed(fields):
if n in self._model.db.field_metadata.keys():
sh.insert(0, (n, d))
sh = self.cleanup_sort_history(sh, ignore_column_map=True)
self._model.sort_history = [tuple(x) for x in sh]
self._model.resort(reset=reset)
col = fields[0][0]
dir = Qt.AscendingOrder if fields[0][1] else Qt.DescendingOrder
if col in self.column_map:
col = self.column_map.index(col)
self.column_header.blockSignals(True)
try:
self.column_header.setSortIndicator(col, dir)
finally:
self.column_header.blockSignals(False)
# }}}
# Ondevice column {{{
def set_ondevice_column_visibility(self):
col, h = self._model.column_map.index('ondevice'), self.column_header
h.setSectionHidden(col, not self._model.device_connected)
def set_device_connected(self, is_connected):
self._model.set_device_connected(is_connected)
self.set_ondevice_column_visibility()
# }}}
# Save/Restore State {{{
def get_state(self):
h = self.column_header
cm = self.column_map
state = {}
state['hidden_columns'] = [cm[i] for i in range(h.count())
if h.isSectionHidden(i) and cm[i] != 'ondevice']
state['last_modified_injected'] = True
state['languages_injected'] = True
state['sort_history'] = \
self.cleanup_sort_history(self.model().sort_history, ignore_column_map=self.is_library_view)
state['column_positions'] = {}
state['column_sizes'] = {}
state['column_alignment'] = self._model.alignment_map
for i in range(h.count()):
name = cm[i]
state['column_positions'][name] = h.visualIndex(i)
if name != 'ondevice':
state['column_sizes'][name] = h.sectionSize(i)
return state
def write_state(self, state):
db = getattr(self.model(), 'db', None)
name = unicode(self.objectName())
if name and db is not None:
db.new_api.set_pref(name + ' books view state', state)
def save_state(self):
# Only save if we have been initialized (set_database called)
if len(self.column_map) > 0 and self.was_restored:
state = self.get_state()
self.write_state(state)
def cleanup_sort_history(self, sort_history, ignore_column_map=False):
history = []
for col, order in sort_history:
if not isinstance(order, bool):
continue
col = {'date':'timestamp', 'sort':'title'}.get(col, col)
if ignore_column_map or col in self.column_map:
if (not history or history[-1][0] != col):
history.append([col, order])
return history
def apply_sort_history(self, saved_history, max_sort_levels=3):
if not saved_history:
return
if self.is_library_view:
for col, order in reversed(self.cleanup_sort_history(
saved_history, ignore_column_map=True)[:max_sort_levels]):
self.sort_by_named_field(col, order)
else:
for col, order in reversed(self.cleanup_sort_history(
saved_history)[:max_sort_levels]):
self.sort_by_column_and_order(self.column_map.index(col), order)
def apply_state(self, state, max_sort_levels=3):
h = self.column_header
cmap = {}
hidden = state.get('hidden_columns', [])
for i, c in enumerate(self.column_map):
cmap[c] = i
if c != 'ondevice':
h.setSectionHidden(i, c in hidden)
positions = state.get('column_positions', {})
pmap = {}
for col, pos in positions.items():
if col in cmap:
pmap[pos] = col
for pos in sorted(pmap.keys()):
col = pmap[pos]
idx = cmap[col]
current_pos = h.visualIndex(idx)
if current_pos != pos:
h.moveSection(current_pos, pos)
# Because of a bug in Qt 5 we have to ensure that the header is actually
# relaid out by changing this value, without this sometimes ghost
# columns remain visible when changing libraries
for i in xrange(h.count()):
val = h.isSectionHidden(i)
h.setSectionHidden(i, not val)
h.setSectionHidden(i, val)
sizes = state.get('column_sizes', {})
for col, size in sizes.items():
if col in cmap:
sz = sizes[col]
if sz < 3:
sz = h.sectionSizeHint(cmap[col])
h.resizeSection(cmap[col], sz)
self.apply_sort_history(state.get('sort_history', None),
max_sort_levels=max_sort_levels)
for col, alignment in state.get('column_alignment', {}).items():
self._model.change_alignment(col, alignment)
for i in range(h.count()):
if not h.isSectionHidden(i) and h.sectionSize(i) < 3:
sz = h.sectionSizeHint(i)
h.resizeSection(i, sz)
def get_default_state(self):
old_state = {
'hidden_columns': ['last_modified', 'languages'],
'sort_history':[DEFAULT_SORT],
'column_positions': {},
'column_sizes': {},
'column_alignment': {
'size':'center',
'timestamp':'center',
'pubdate':'center'},
'last_modified_injected': True,
'languages_injected': True,
}
h = self.column_header
cm = self.column_map
for i in range(h.count()):
name = cm[i]
old_state['column_positions'][name] = i
if name != 'ondevice':
old_state['column_sizes'][name] = \
min(350, max(self.sizeHintForColumn(i),
h.sectionSizeHint(i)))
if name in ('timestamp', 'last_modified'):
old_state['column_sizes'][name] += 12
return old_state
def get_old_state(self):
ans = None
name = unicode(self.objectName())
if name:
name += ' books view state'
db = getattr(self.model(), 'db', None)
if db is not None:
ans = db.prefs.get(name, None)
if ans is None:
ans = gprefs.get(name, None)
try:
del gprefs[name]
except:
pass
if ans is not None:
db.new_api.set_pref(name, ans)
else:
injected = False
if not ans.get('last_modified_injected', False):
injected = True
ans['last_modified_injected'] = True
hc = ans.get('hidden_columns', [])
if 'last_modified' not in hc:
hc.append('last_modified')
if not ans.get('languages_injected', False):
injected = True
ans['languages_injected'] = True
hc = ans.get('hidden_columns', [])
if 'languages' not in hc:
hc.append('languages')
if injected:
db.new_api.set_pref(name, ans)
return ans
def restore_state(self):
old_state = self.get_old_state()
if old_state is None:
old_state = self.get_default_state()
max_levels = 3
if tweaks['sort_columns_at_startup'] is not None:
sh = []
try:
for c,d in tweaks['sort_columns_at_startup']:
if not isinstance(d, bool):
d = True if d == 0 else False
sh.append((c, d))
except:
# Ignore invalid tweak values as users seem to often get them
# wrong
print('Ignoring invalid sort_columns_at_startup tweak, with error:')
import traceback
traceback.print_exc()
old_state['sort_history'] = sh
max_levels = max(3, len(sh))
self.column_header.blockSignals(True)
self.apply_state(old_state, max_sort_levels=max_levels)
self.column_header.blockSignals(False)
self.do_row_sizing()
self.was_restored = True
def refresh_row_sizing(self):
self.row_sizing_done = False
self.do_row_sizing()
def do_row_sizing(self):
# Resize all rows to have the correct height
if not self.row_sizing_done and self.model().rowCount(QModelIndex()) > 0:
vh = self.verticalHeader()
vh.setDefaultSectionSize(max(vh.minimumSectionSize(), self.default_row_height + gprefs['book_list_extra_row_spacing']))
self._model.set_row_height(self.rowHeight(0))
self.row_sizing_done = True
def resize_column_to_fit(self, column):
col = self.column_map.index(column)
self.column_resized(col, self.columnWidth(col), self.columnWidth(col))
def column_resized(self, col, old_size, new_size):
# arbitrary: scroll bar + header + some
max_width = self.width() - (self.verticalScrollBar().width() +
self.verticalHeader().width() + 10)
if max_width < 200:
max_width = 200
if new_size > max_width:
self.column_header.blockSignals(True)
self.setColumnWidth(col, max_width)
self.column_header.blockSignals(False)
# }}}
# Initialization/Delegate Setup {{{
def set_database(self, db):
self.alternate_views.set_database(db)
self.save_state()
self._model.set_database(db)
self.tags_delegate.set_database(db)
self.cc_names_delegate.set_database(db)
self.authors_delegate.set_database(db)
self.series_delegate.set_auto_complete_function(db.all_series)
self.publisher_delegate.set_auto_complete_function(db.all_publishers)
self.alternate_views.set_database(db, stage=1)
def marked_changed(self, old_marked, current_marked):
self.alternate_views.marked_changed(old_marked, current_marked)
if bool(old_marked) == bool(current_marked):
changed = old_marked | current_marked
i = self.model().db.data.id_to_index
def f(x):
try:
return i(x)
except ValueError:
pass
sections = tuple(x for x in map(f, changed) if x is not None)
if sections:
self.row_header.headerDataChanged(Qt.Vertical, min(sections), max(sections))
# This is needed otherwise Qt does not always update the
# viewport correctly. See https://bugs.launchpad.net/bugs/1404697
self.row_header.viewport().update()
else:
# Marked items have either appeared or all been removed
self.model().set_row_decoration(current_marked)
self.row_header.headerDataChanged(Qt.Vertical, 0, self.row_header.count()-1)
self.row_header.geometriesChanged.emit()
def database_changed(self, db):
db.data.add_marked_listener(self.marked_changed_listener)
for i in range(self.model().columnCount(None)):
if self.itemDelegateForColumn(i) in (self.rating_delegate,
self.timestamp_delegate, self.pubdate_delegate,
self.last_modified_delegate, self.languages_delegate):
self.setItemDelegateForColumn(i, self.itemDelegate())
cm = self.column_map
for colhead in cm:
if self._model.is_custom_column(colhead):
cc = self._model.custom_columns[colhead]
if cc['datatype'] == 'datetime':
delegate = CcDateDelegate(self)
delegate.set_format(cc['display'].get('date_format',''))
self.setItemDelegateForColumn(cm.index(colhead), delegate)
elif cc['datatype'] == 'comments':
self.setItemDelegateForColumn(cm.index(colhead), self.cc_comments_delegate)
elif cc['datatype'] == 'text':
if cc['is_multiple']:
if cc['display'].get('is_names', False):
self.setItemDelegateForColumn(cm.index(colhead),
self.cc_names_delegate)
else:
self.setItemDelegateForColumn(cm.index(colhead),
self.tags_delegate)
else:
self.setItemDelegateForColumn(cm.index(colhead), self.cc_text_delegate)
elif cc['datatype'] == 'series':
self.setItemDelegateForColumn(cm.index(colhead), self.cc_text_delegate)
elif cc['datatype'] in ('int', 'float'):
self.setItemDelegateForColumn(cm.index(colhead), self.cc_number_delegate)
elif cc['datatype'] == 'bool':
self.setItemDelegateForColumn(cm.index(colhead), self.cc_bool_delegate)
elif cc['datatype'] == 'rating':
self.setItemDelegateForColumn(cm.index(colhead), self.rating_delegate)
elif cc['datatype'] == 'composite':
self.setItemDelegateForColumn(cm.index(colhead), self.cc_template_delegate)
elif cc['datatype'] == 'enumeration':
self.setItemDelegateForColumn(cm.index(colhead), self.cc_enum_delegate)
else:
dattr = colhead+'_delegate'
delegate = colhead if hasattr(self, dattr) else 'text'
self.setItemDelegateForColumn(cm.index(colhead), getattr(self,
delegate+'_delegate'))
self.restore_state()
self.set_ondevice_column_visibility()
# incase there were marked books
self.model().set_row_decoration(set())
self.row_header.headerDataChanged(Qt.Vertical, 0, self.row_header.count()-1)
self.row_header.geometriesChanged.emit()
# }}}
# Context Menu {{{
def set_context_menu(self, menu, edit_collections_action):
self.setContextMenuPolicy(Qt.DefaultContextMenu)
self.context_menu = menu
self.alternate_views.set_context_menu(menu)
self.edit_collections_action = edit_collections_action
def contextMenuEvent(self, event):
sac = self.gui.iactions['Sort By']
sort_added = tuple(ac for ac in self.context_menu.actions() if ac is sac.qaction)
if sort_added:
sac.update_menu()
self.context_menu.popup(event.globalPos())
event.accept()
# }}}
@property
def column_map(self):
return self._model.column_map
@property
def visible_columns(self):
h = self.horizontalHeader()
logical_indices = (x for x in xrange(h.count()) if not h.isSectionHidden(x))
rmap = {i:x for i, x in enumerate(self.column_map)}
return (rmap[h.visualIndex(x)] for x in logical_indices if h.visualIndex(x) > -1)
def refresh_book_details(self):
idx = self.currentIndex()
if idx.isValid():
self._model.current_changed(idx, idx)
return True
return False
def scrollContentsBy(self, dx, dy):
# Needed as Qt bug causes headerview to not always update when scrolling
QTableView.scrollContentsBy(self, dx, dy)
if dy != 0:
self.column_header.update()
def scroll_to_row(self, row):
if row > -1:
h = self.horizontalHeader()
for i in range(h.count()):
if not h.isSectionHidden(i) and h.sectionViewportPosition(i) >= 0:
self.scrollTo(self.model().index(row, i), self.PositionAtCenter)
break
@property
def current_book(self):
ci = self.currentIndex()
if ci.isValid():
try:
return self.model().db.data.index_to_id(ci.row())
except (IndexError, ValueError, KeyError, TypeError, AttributeError):
pass
def current_book_state(self):
return self.current_book, self.horizontalScrollBar().value()
def restore_current_book_state(self, state):
book_id, hpos = state
try:
row = self.model().db.data.id_to_index(book_id)
except (IndexError, ValueError, KeyError, TypeError, AttributeError):
return
self.set_current_row(row)
self.scroll_to_row(row)
self.horizontalScrollBar().setValue(hpos)
def set_current_row(self, row=0, select=True, for_sync=False):
if row > -1 and row < self.model().rowCount(QModelIndex()):
h = self.horizontalHeader()
logical_indices = list(range(h.count()))
logical_indices = [x for x in logical_indices if not
h.isSectionHidden(x)]
pairs = [(x, h.visualIndex(x)) for x in logical_indices if
h.visualIndex(x) > -1]
if not pairs:
pairs = [(0, 0)]
pairs.sort(cmp=lambda x,y:cmp(x[1], y[1]))
i = pairs[0][0]
index = self.model().index(row, i)
if for_sync:
sm = self.selectionModel()
sm.setCurrentIndex(index, sm.NoUpdate)
else:
self.setCurrentIndex(index)
if select:
sm = self.selectionModel()
sm.select(index, sm.ClearAndSelect|sm.Rows)
def row_at_top(self):
pos = 0
while pos < 100:
ans = self.rowAt(pos)
if ans > -1:
return ans
pos += 5
def row_at_bottom(self):
pos = self.viewport().height()
limit = pos - 100
while pos > limit:
ans = self.rowAt(pos)
if ans > -1:
return ans
pos -= 5
def moveCursor(self, action, modifiers):
orig = self.currentIndex()
index = QTableView.moveCursor(self, action, modifiers)
if action == QTableView.MovePageDown:
moved = index.row() - orig.row()
try:
rows = self.row_at_bottom() - self.row_at_top()
except TypeError:
rows = moved
if moved > rows:
index = self.model().index(orig.row() + rows, index.column())
elif action == QTableView.MovePageUp:
moved = orig.row() - index.row()
try:
rows = self.row_at_bottom() - self.row_at_top()
except TypeError:
rows = moved
if moved > rows:
index = self.model().index(orig.row() - rows, index.column())
elif action == QTableView.MoveHome and modifiers & Qt.ControlModifier:
return self.model().index(0, orig.column())
elif action == QTableView.MoveEnd and modifiers & Qt.ControlModifier:
return self.model().index(self.model().rowCount(QModelIndex()) - 1, orig.column())
return index
def selectionCommand(self, index, event):
if event and event.type() == event.KeyPress and event.key() in (Qt.Key_Home, Qt.Key_End) and event.modifiers() & Qt.CTRL:
return QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows
return super(BooksView, self).selectionCommand(index, event)
def ids_to_rows(self, ids):
row_map = OrderedDict()
ids = frozenset(ids)
m = self.model()
for row in xrange(m.rowCount(QModelIndex())):
if len(row_map) >= len(ids):
break
c = m.id(row)
if c in ids:
row_map[c] = row
return row_map
def select_rows(self, identifiers, using_ids=True, change_current=True,
scroll=True):
'''
Select rows identified by identifiers. identifiers can be a set of ids,
row numbers or QModelIndexes.
'''
rows = set([x.row() if hasattr(x, 'row') else x for x in
identifiers])
if using_ids:
rows = set([])
identifiers = set(identifiers)
m = self.model()
for row in xrange(m.rowCount(QModelIndex())):
if m.id(row) in identifiers:
rows.add(row)
rows = list(sorted(rows))
if rows:
row = rows[0]
if change_current:
self.set_current_row(row, select=False)
if scroll:
self.scroll_to_row(row)
sm = self.selectionModel()
sel = QItemSelection()
m = self.model()
max_col = m.columnCount(QModelIndex()) - 1
# Create a range based selector for each set of contiguous rows
# as supplying selectors for each individual row causes very poor
# performance if a large number of rows has to be selected.
for k, g in itertools.groupby(enumerate(rows), lambda (i,x):i-x):
group = list(map(operator.itemgetter(1), g))
sel.merge(QItemSelection(m.index(min(group), 0),
m.index(max(group), max_col)), sm.Select)
sm.select(sel, sm.ClearAndSelect)
class Scheduler(QObject):
INTERVAL = 1 # minutes
delete_old_news = pyqtSignal(object)
start_recipe_fetch = pyqtSignal(object)
def __init__(self, parent, db):
QObject.__init__(self, parent)
self.internet_connection_failed = False
self._parent = parent
self.no_internet_msg = _('Cannot download news as no internet connection '
'is active')
self.no_internet_dialog = d = error_dialog(self._parent,
self.no_internet_msg, _('No internet connection'),
show_copy_button=False)
d.setModal(False)
self.recipe_model = RecipeModel()
self.db = db
self.lock = QMutex(QMutex.Recursive)
self.download_queue = set([])
self.news_menu = QMenu()
self.news_icon = QIcon(I('news.png'))
self.scheduler_action = QAction(QIcon(I('scheduler.png')), _('Schedule news download'), self)
self.news_menu.addAction(self.scheduler_action)
self.scheduler_action.triggered[bool].connect(self.show_dialog)
self.cac = QAction(QIcon(I('user_profile.png')), _('Add a custom news source'), self)
self.cac.triggered[bool].connect(self.customize_feeds)
self.news_menu.addAction(self.cac)
self.news_menu.addSeparator()
self.all_action = self.news_menu.addAction(
_('Download all scheduled news sources'),
self.download_all_scheduled)
self.timer = QTimer(self)
self.timer.start(int(self.INTERVAL * 60 * 1000))
self.timer.timeout.connect(self.check)
self.oldest = gconf['oldest_news']
QTimer.singleShot(5 * 1000, self.oldest_check)
def database_changed(self, db):
self.db = db
def oldest_check(self):
if self.oldest > 0:
delta = timedelta(days=self.oldest)
try:
ids = list(self.db.tags_older_than(_('News'),
delta, must_have_authors=['calibre']))
except:
# Happens if library is being switched
ids = []
if ids:
if ids:
self.delete_old_news.emit(ids)
QTimer.singleShot(60 * 60 * 1000, self.oldest_check)
def show_dialog(self, *args):
self.lock.lock()
try:
d = SchedulerDialog(self.recipe_model)
d.download.connect(self.download_clicked)
d.exec_()
gconf['oldest_news'] = self.oldest = d.old_news.value()
d.break_cycles()
finally:
self.lock.unlock()
def customize_feeds(self, *args):
from calibre.gui2.dialogs.user_profiles import UserProfiles
d = UserProfiles(self._parent, self.recipe_model)
try:
d.exec_()
d.break_cycles()
finally:
d.deleteLater()
def do_download(self, urn):
self.lock.lock()
try:
account_info = self.recipe_model.get_account_info(urn)
customize_info = self.recipe_model.get_customize_info(urn)
recipe = self.recipe_model.recipe_from_urn(urn)
un = pw = None
if account_info is not None:
un, pw = account_info
add_title_tag, custom_tags, keep_issues = customize_info
script = self.recipe_model.get_recipe(urn)
pt = PersistentTemporaryFile('_builtin.recipe')
pt.write(script)
pt.close()
arg = {
'username': un,
'password': pw,
'add_title_tag':add_title_tag,
'custom_tags':custom_tags,
'recipe':pt.name,
'title':recipe.get('title',''),
'urn':urn,
'keep_issues':keep_issues
}
self.download_queue.add(urn)
self.start_recipe_fetch.emit(arg)
finally:
self.lock.unlock()
def recipe_downloaded(self, arg):
self.lock.lock()
try:
self.recipe_model.update_last_downloaded(arg['urn'])
self.download_queue.remove(arg['urn'])
finally:
self.lock.unlock()
def recipe_download_failed(self, arg):
self.lock.lock()
try:
self.recipe_model.update_last_downloaded(arg['urn'])
self.download_queue.remove(arg['urn'])
finally:
self.lock.unlock()
def download_clicked(self, urn):
if urn is not None:
return self.download(urn)
for urn in self.recipe_model.scheduled_urns():
if not self.download(urn):
break
def download_all_scheduled(self):
self.download_clicked(None)
def has_internet_connection(self):
if not internet_connected():
if not self.internet_connection_failed:
self.internet_connection_failed = True
if self._parent.is_minimized_to_tray:
self._parent.status_bar.show_message(self.no_internet_msg,
5000)
elif not self.no_internet_dialog.isVisible():
self.no_internet_dialog.show()
return False
self.internet_connection_failed = False
if self.no_internet_dialog.isVisible():
self.no_internet_dialog.hide()
return True
def download(self, urn):
self.lock.lock()
if not self.has_internet_connection():
return False
doit = urn not in self.download_queue
self.lock.unlock()
if doit:
self.do_download(urn)
return True
def check(self):
recipes = self.recipe_model.get_to_be_downloaded_recipes()
for urn in recipes:
if not self.download(urn):
# No internet connection, we will try again in a minute
break
