def contextMenuEvent(self, ev):
cm = QMenu(self)
paste = cm.addAction(QIcon.ic('edit-paste.png'), _('Paste cover'))
copy = cm.addAction(QIcon.ic('edit-copy.png'), _('Copy cover'))
save = cm.addAction(QIcon.ic('save.png'), _('Save cover to disk'))
remove = cm.addAction(QIcon.ic('trash.png'), _('Remove cover'))
gc = cm.addAction(QIcon.ic('default_cover.png'), _('Generate cover from metadata'))
cm.addSeparator()
if self.pixmap is not self.default_pixmap and self.data.get('id'):
book_id = self.data['id']
cm.tc = QMenu(_('Trim cover'))
cm.tc.addAction(QIcon.ic('trim.png'), _('Automatically trim borders'), self.trim_cover)
cm.tc.addAction(_('Trim borders manually'), self.manual_trim_cover)
cm.tc.addSeparator()
cm.tc.addAction(QIcon.ic('edit-undo.png'), _('Undo last trim'), self.undo_last_trim).setEnabled(self.last_trim_id == book_id)
cm.addMenu(cm.tc)
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 contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(_('Set to undefined') + '\t' + QKeySequence(Qt.Key.Key_Space).toString(QKeySequence.SequenceFormat.NativeText),
self.clear_to_undefined)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m)
m.popup(ev.globalPos())
def contextMenuEvent(self, ev):
menu = QMenu(self)
data = self._page.contextMenuData()
url = data.linkUrl()
url = str(url.toString(NO_URL_FORMATTING)).strip()
text = data.selectedText()
if text:
ca = self.pageAction(QWebEnginePage.WebAction.Copy)
if ca.isEnabled():
menu.addAction(ca)
menu.addAction(actions['reload-preview'])
menu.addAction(QIcon(I('debug.png')), _('Inspect element'), self.inspect)
if url.partition(':')[0].lower() in {'http', 'https'}:
menu.addAction(_('Open link'), partial(safe_open_url, data.linkUrl()))
if QWebEngineContextMenuData.MediaType.MediaTypeImage <= data.mediaType() <= QWebEngineContextMenuData.MediaType.MediaTypeFile:
url = data.mediaUrl()
if url.scheme() == FAKE_PROTOCOL:
href = url.path().lstrip('/')
if href:
c = current_container()
resource_name = c.href_to_name(href)
if resource_name and c.exists(resource_name) and resource_name not in c.names_that_must_not_be_changed:
self.add_open_with_actions(menu, resource_name)
if data.mediaType() == QWebEngineContextMenuData.MediaType.MediaTypeImage:
mime = c.mime_map[resource_name]
if mime.startswith('image/'):
menu.addAction(_('Edit %s') % resource_name, partial(self.edit_image, resource_name))
menu.exec_(ev.globalPos())
def show_context_menu(self, pos):
menu = QMenu(self)
menu.addAction(QIcon.ic('plus.png'), _('Expand all'),
self.plugin_view.expandAll)
menu.addAction(QIcon.ic('minus.png'), _('Collapse all'),
self.plugin_view.collapseAll)
menu.exec(self.plugin_view.mapToGlobal(pos))
def show_context_menu(self, point):
idx = self.table.indexAt(point)
if idx.column() != 0:
return
m = self.au_context_menu = QMenu(self)
item = self.table.itemAt(point)
disable_copy_paste_search = len(
self.table.selectedItems()) != 1 or item.is_deleted
ca = m.addAction(_('Copy'))
ca.triggered.connect(partial(self.copy_to_clipboard, item))
if disable_copy_paste_search:
ca.setEnabled(False)
ca = m.addAction(_('Paste'))
ca.triggered.connect(partial(self.paste_from_clipboard, item))
if disable_copy_paste_search:
ca.setEnabled(False)
ca = m.addAction(_('Undo'))
ca.triggered.connect(self.undo_edit)
ca.setEnabled(False)
for item in self.table.selectedItems():
if (item.text() != self.original_names[int(
item.data(Qt.ItemDataRole.UserRole))] or item.is_deleted):
ca.setEnabled(True)
break
ca = m.addAction(_('Edit'))
ca.triggered.connect(self.rename_tag)
ca = m.addAction(_('Delete'))
ca.triggered.connect(self.delete_tags)
item_name = unicode_type(item.text())
ca = m.addAction(_('Search for {}').format(item_name))
ca.triggered.connect(partial(self.set_search_text, item_name))
item_name = unicode_type(item.text())
ca = m.addAction(_('Filter by {}').format(item_name))
ca.triggered.connect(partial(self.set_filter_text, item_name))
if self.category is not None:
ca = m.addAction(_("Search the library for {0}").format(item_name))
ca.triggered.connect(partial(self.search_for_books, item))
if disable_copy_paste_search:
ca.setEnabled(False)
if self.table.state() == QAbstractItemView.State.EditingState:
m.addSeparator()
case_menu = QMenu(_('Change case'))
action_upper_case = case_menu.addAction(_('Upper case'))
action_lower_case = case_menu.addAction(_('Lower case'))
action_swap_case = case_menu.addAction(_('Swap case'))
action_title_case = case_menu.addAction(_('Title case'))
action_capitalize = case_menu.addAction(_('Capitalize'))
action_upper_case.triggered.connect(
partial(self.do_case, icu_upper))
action_lower_case.triggered.connect(
partial(self.do_case, icu_lower))
action_swap_case.triggered.connect(
partial(self.do_case, self.swap_case))
action_title_case.triggered.connect(
partial(self.do_case, titlecase))
action_capitalize.triggered.connect(
partial(self.do_case, capitalize))
m.addMenu(case_menu)
m.exec_(self.table.mapToGlobal(point))
def show_context_menu(self, point):
item = self.folders.itemAt(point)
if item is None:
return
m = QMenu(self)
m.addAction(QIcon(I('mimetypes/dir.png')), _('Create new folder'), partial(self.create_folder, item))
m.popup(self.folders.mapToGlobal(point))
def contextMenuEvent(self, ev):
menu = self.createStandardContextMenu()
for action in menu.actions():
parts = action.text().split('\t')
if len(parts) == 2 and QKeySequence(QKeySequence.StandardKey.Paste).toString(QKeySequence.SequenceFormat.NativeText) in parts[-1]:
menu.insertAction(action, self.action_paste_and_match_style)
break
else:
menu.addAction(self.action_paste_and_match_style)
st = self.text()
m = QMenu(_('Fonts'))
m.addAction(self.action_bold), m.addAction(self.action_italic), m.addAction(self.action_underline)
menu.addMenu(m)
if st and st.strip():
self.create_change_case_menu(menu)
parent = self._parent()
if hasattr(parent, 'toolbars_visible'):
vis = parent.toolbars_visible
menu.addAction(_('%s toolbars') % (_('Hide') if vis else _('Show')), parent.toggle_toolbars)
menu.addSeparator()
am = QMenu(_('Advanced'))
menu.addMenu(am)
am.addAction(self.action_block_style)
am.addAction(self.action_insert_link)
am.addAction(self.action_background)
am.addAction(self.action_color)
menu.addAction(_('Smarten punctuation'), parent.smarten_punctuation)
menu.exec_(ev.globalPos())
def init_find_in_grouped_search(menu, field, value, book_info):
from calibre.gui2.ui import get_gui
db = get_gui().current_db
fm = db.field_metadata
field_name = fm.get(field, {}).get('name', None)
if field_name is None:
# I don't think this can ever happen, but ...
return
gsts = db.prefs.get('grouped_search_terms', {})
gsts_to_show = []
for v in gsts:
fk = fm.search_term_to_field_key(v)
if field in fk:
gsts_to_show.append(v)
if gsts_to_show:
m = QMenu((_('Search calibre for %s') + '...')%escape_for_menu(value), menu)
m.setIcon(QIcon(I('search.png')))
menu.addMenu(m)
m.addAction(QIcon(get_icon_path(field, '')),
_('in category %s')%escape_for_menu(field_name),
lambda g=field: book_info.search_requested(
'{}:"={}"'.format(g, value.replace('"', r'\"')), ''))
for gst in gsts_to_show:
icon_path = get_icon_path(gst, '@')
m.addAction(QIcon(icon_path),
_('in grouped search %s')%gst,
lambda g=gst: book_info.search_requested(
'{}:"={}"'.format(g, value.replace('"', r'\"')), ''))
else:
menu.addAction(QIcon(I('search.png')),
_('Search calibre for {val} in category {name}').format(
val=escape_for_menu(value), name=escape_for_menu(field_name)),
lambda g=field: book_info.search_requested(
'{}:"={}"'.format(g, value.replace('"', r'\"')), ''))
def show_context_menu(self, point):
idx = self.currentIndex()
if idx and idx.isValid() and not idx.data(Qt.ItemDataRole.UserRole):
m = QMenu(self)
m.addAction(QIcon(I('view.png')), _('View this cover at full size'), self.show_cover)
m.addAction(QIcon(I('edit-copy.png')), _('Copy this cover to clipboard'), self.copy_cover)
m.exec_(QCursor.pos())
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
def show_context_menu(self, pos):
m = QMenu(self)
a = m.addAction(_('Customize this toolbar'))
a.triggered.connect(self.customize)
a = m.addAction(_('Hide this toolbar'))
a.triggered.connect(self.hide_toolbar)
m.exec(self.mapToGlobal(pos))
def context_menu_requested(self, widget, ev):
if isinstance(widget, Heading):
start = widget
else:
found = False
for w in reversed(self.widgets):
if w is widget:
found = True
elif found and isinstance(w, Heading):
start = w
break
else:
return
found = False
lines = []
for w in self.widgets:
if found and isinstance(w, Heading):
break
if w is start:
found = True
if found:
lines += w.lines_for_copy
if not lines:
return
block = '\n'.join(lines).replace('\xa0', ' ')
heading = lines[0]
m = QMenu(self)
m.addAction(QIcon(I('edit-copy.png')), _('Copy') + ' ' + heading.replace('\xa0', ' '), lambda : QApplication.instance().clipboard().setText(block))
all_lines = []
for w in self.widgets:
all_lines += w.lines_for_copy
all_text = '\n'.join(all_lines).replace('\xa0', ' ')
m.addAction(QIcon(I('edit-copy.png')), _('Copy everything'), lambda : QApplication.instance().clipboard().setText(all_text))
m.exec(ev.globalPos())
def build_menu(self, action):
m = action.menu()
ac = MenuAction(action, self)
if m is None:
m = QMenu()
m.addAction(action)
ac.setMenu(m)
return ac
def build_category_context_menu(self, item):
m = QMenu(self)
cn = str(item.data(0, NAME_ROLE) or '')
if cn:
name = item.data(0, Qt.DisplayRole)
m.addAction(_('Select all {} files').format(name), partial(self.select_all_in_category, cn))
m.addAction(_('De-select all {} files').format(name), partial(self.deselect_all_in_category, cn))
return m
def context_menu(self, pos):
m = QMenu(self)
if self.items.count() > 0:
m.addAction(QIcon(I('edit-copy.png')),
_('Copy list of errors to clipboard'),
self.copy_to_clipboard)
if list(m.actions()):
m.exec(self.mapToGlobal(pos))
def add_format_entries(menu, data, book_info, copy_menu, search_menu):
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(search_menu, book_info.find_in_tag_browser_action, 'formats', fmt)
init_find_in_grouped_search(search_menu, 'formats', fmt, book_info)
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 edit_programs, populate_menu
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 format') % 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(_('Path to file'))
copy_menu.addAction(ac)
def create_context_menu(self):
m = QMenu(self)
m.addAction(_('Set date to undefined') + '\t' + QKeySequence(Qt.Key.Key_Minus).toString(QKeySequence.SequenceFormat.NativeText),
self.clear_date)
m.addAction(_('Set date to today') + '\t' + QKeySequence(Qt.Key.Key_Equal).toString(QKeySequence.SequenceFormat.NativeText),
self.today_date)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m, use_self_for_copy_actions=True)
return m
def build_context_menu(self):
cm = QMenu(self)
paste = cm.addAction(QIcon.ic('edit-paste.png'), _('Paste cover'))
copy = cm.addAction(QIcon.ic('edit-copy.png'), _('Copy cover'))
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
return cm
def create_search_internet_menu(callback, author=None):
m = QMenu((_('Search the internet for the author {}').format(author) if
author is not None else _('Search the internet for this book')))
m.menuAction().setIcon(QIcon(I('search.png')))
items = all_book_searches() if author is None else all_author_searches()
for k in sorted(items, key=lambda k: name_for(k).lower()):
m.addAction(QIcon(I('search.png')), name_for(k),
partial(callback, InternetSearch(author, k)))
return m
def publish_new_menu(self):
menu = self.notifier.contextMenu()
if menu is None:
menu = QMenu()
if len(menu.actions()) == 0:
menu.addAction(self.notifier.icon(), _('Show/hide %s') % self.title, self.notifier.emit_activated)
# The menu must have at least one entry, namely the show/hide entry.
# This is necessary as Canonical in their infinite wisdom decided to
# force all tray icons to show their popup menus when clicked.
self.dbus_menu.publish_new_menu(menu)
def clone_one_menu(m):
m.aboutToShow.emit()
ans = QMenu(m.parent())
for ac in m.actions():
cac = clone_action(ac, ans)
ans.addAction(cac)
m = ac.menu()
if m is not None:
cac.setMenu(clone_menu(m))
return ans
def create_application_menubar(cls):
if not cls.__actions:
mb = QMenuBar(None)
menu = QMenu()
for action in cls.get_menubar_actions():
menu.addAction(action)
cls.__actions.append(action)
mb.addMenu(menu)
cls.___menu_bar = mb
cls.___menu = menu
return cls.__actions
def show_context_menu(self, pos):
menu = QMenu(self)
menu.addAction(actions['edit-toc'])
menu.addAction(_('&Expand all'), self.view.expandAll)
menu.addAction(_('&Collapse all'), self.view.collapseAll)
menu.addAction(self.refresh_action)
menu.exec_(self.view.mapToGlobal(pos))
def contextMenuEvent(self, event):
index = self.indexAt(event.pos())
if not index.isValid():
return
result = self.model().get_result(index)
menu = QMenu(self)
da = menu.addAction(_('Download...'), partial(self.download_requested.emit, result))
if not result.downloads:
da.setEnabled(False)
menu.addSeparator()
menu.addAction(_('Show in store'), partial(self.open_requested.emit, result))
menu.exec(event.globalPos())
def create_change_case_menu(self, menu):
case_menu = QMenu(_('Change case'), menu)
action_upper_case = case_menu.addAction(_('Upper case'))
action_lower_case = case_menu.addAction(_('Lower case'))
action_swap_case = case_menu.addAction(_('Swap case'))
action_title_case = case_menu.addAction(_('Title case'))
action_capitalize = case_menu.addAction(_('Capitalize'))
action_upper_case.triggered.connect(self.upper_case)
action_lower_case.triggered.connect(self.lower_case)
action_swap_case.triggered.connect(self.swap_case)
action_title_case.triggered.connect(self.title_case)
action_capitalize.triggered.connect(self.capitalize)
menu.addMenu(case_menu)
return case_menu
def build_menu(self, ac):
ans = CloneAction(ac, self.native_menubar, is_top_level=True)
if ans.menu() is None:
m = QMenu()
m.addAction(CloneAction(ac, self.native_menubar))
ans.setMenu(m)
# Qt (as of 5.3.0) does not update global menubar entries
# correctly, so we have to rebuild the global menubar.
# Without this the Choose Library action shows the text
# 'Untitled' and the Location Manager items do not work.
ans.text_changed.connect(self.refresh_timer.start)
ans.visibility_changed.connect(self.refresh_timer.start)
self.native_menubar.addAction(ans)
self.added_actions.append(ans)
return ans
def create_open_cover_with_menu(self, parent_menu):
from calibre.gui2.open_with import edit_programs, populate_menu
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 with...'), 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 show_context_menu(self, point):
self.context_item = self.table.itemAt(point)
case_menu = QMenu(_('Change case'))
case_menu.setIcon(QIcon(I('font_size_larger.png')))
action_upper_case = case_menu.addAction(_('Upper case'))
action_lower_case = case_menu.addAction(_('Lower case'))
action_swap_case = case_menu.addAction(_('Swap case'))
action_title_case = case_menu.addAction(_('Title case'))
action_capitalize = case_menu.addAction(_('Capitalize'))
action_upper_case.triggered.connect(self.upper_case)
action_lower_case.triggered.connect(self.lower_case)
action_swap_case.triggered.connect(self.swap_case)
action_title_case.triggered.connect(self.title_case)
action_capitalize.triggered.connect(self.capitalize)
m = self.au_context_menu = QMenu(self)
idx = self.table.indexAt(point)
id_ = int(self.table.item(idx.row(), 0).data(Qt.ItemDataRole.UserRole))
sub = self.get_column_name(idx.column())
if self.context_item.text() != self.original_authors[id_][sub]:
ca = m.addAction(QIcon(I('undo.png')), _('Undo'))
ca.triggered.connect(
partial(self.undo_cell,
old_value=self.original_authors[id_][sub]))
m.addSeparator()
ca = m.addAction(QIcon(I('edit-copy.png')), _('Copy'))
ca.triggered.connect(self.copy_to_clipboard)
ca = m.addAction(QIcon(I('edit-paste.png')), _('Paste'))
ca.triggered.connect(self.paste_from_clipboard)
m.addSeparator()
if self.context_item is not None and self.context_item.column() == 0:
ca = m.addAction(_('Copy to author sort'))
ca.triggered.connect(self.copy_au_to_aus)
m.addSeparator()
ca = m.addAction(QIcon(I('lt.png')),
_("Show books by author in book list"))
ca.triggered.connect(self.search_in_book_list)
else:
ca = m.addAction(_('Copy to author'))
ca.triggered.connect(self.copy_aus_to_au)
m.addSeparator()
m.addMenu(case_menu)
m.exec(self.table.mapToGlobal(point))
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 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())
