def setter(w, val):
order_map = {x: i for i, x in enumerate(val)}
items = list(w.defaults)
limit = len(items)
items.sort(key=lambda x: order_map.get(x, limit))
w.clear()
for x in items:
i = QListWidgetItem(w)
i.setText(x)
i.setFlags(i.flags() | Qt.ItemIsDragEnabled)
def resort(self):
if self.sort_alphabetically.isChecked():
sorted_locations = sorted(self.locations, key=lambda name_loc: numeric_sort_key(name_loc[0]))
else:
sorted_locations = self.locations
self.items.clear()
for name, loc in sorted_locations:
i = QListWidgetItem(name, self.items)
i.setData(Qt.UserRole, loc)
self.items.setCurrentRow(0)
def entry_to_item(entry, parent):
icon = get_icon(entry.get('icon_file'), as_data=False)
if icon is None:
icon = entry_to_icon_text(entry)[0]
else:
icon = QPixmap.fromImage(icon)
ans = QListWidgetItem(QIcon(icon),
entry.get('name') or _('Unknown'), parent)
ans.setData(ENTRY_ROLE, entry)
ans.setToolTip(_('Application path:') + '\n' + entry['path'])
def entry_to_item(entry, parent):
icon_path = entry.get('Icon') or I('blank.png')
if not isinstance(icon_path, string_or_bytes):
icon_path = I('blank.png')
ans = QListWidgetItem(QIcon(icon_path), entry.get('Name') or _('Unknown'), parent)
ans.setData(ENTRY_ROLE, entry)
comment = (entry.get('Comment') or '')
if comment:
comment += '\n'
ans.setToolTip(comment + _('Command line:') + '\n' + (' '.join(entry['Exec'])))
def fset(self, wl):
self.dictionary_list.clear()
for langcode, url in sorted(
wl.iteritems(),
key=lambda
(lc, url): sort_key(calibre_langcode_to_name(lc))):
i = QListWidgetItem(
'%s: %s' % (calibre_langcode_to_name(langcode), url),
self.dictionary_list)
i.setData(Qt.UserRole, (langcode, url))
def create_color_scheme(self):
scheme = self.colors_map[self.current_colors].data(Qt.ItemDataRole.UserRole)
d = CreateColorScheme('#' + _('My Color Scheme'), scheme, set(self.colors_map), parent=self)
if d.exec_() == QDialog.DialogCode.Accepted:
name, scheme = d.data
li = QListWidgetItem(name)
li.setData(Qt.ItemDataRole.UserRole, scheme), li.setFlags(li.flags() | Qt.ItemFlag.ItemIsUserCheckable), li.setCheckState(Qt.CheckState.Checked)
self.insert_scheme(name, li)
self.emit_changed()
self.original_prefs['color_themes'] = self.current_prefs['color_themes']
def set_bookmarks(self, bookmarks=()):
self.bookmarks_list.clear()
for bm in bookmarks:
if bm['title'] != 'calibre_current_page_bookmark':
i = QListWidgetItem(bm['title'])
i.setData(Qt.UserRole, self.bm_to_item(bm))
i.setFlags(i.flags() | Qt.ItemIsEditable)
self.bookmarks_list.addItem(i)
if self.bookmarks_list.count() > 0:
self.bookmarks_list.setCurrentItem(self.bookmarks_list.item(0), QItemSelectionModel.ClearAndSelect)
def to_item(key, ac, parent):
ic = ac.icon()
if not ic or ic.isNull():
ic = blank
ans = QListWidgetItem(ic,
unicode_type(ac.text()).replace('&', ''),
parent)
ans.setData(Qt.ItemDataRole.UserRole, key)
ans.setToolTip(ac.toolTip())
return ans
def _addReference(self):
dialog = NewReferenceDialog(self.parent().db, RelationReference)
if dialog.exec_():
references = dialog.getValues()
for reference in references:
reference.relation_id = self.relation.id
self.parent().db.commit(reference)
item = QListWidgetItem()
item.setData(Qt.UserRole, reference)
item.setText("{}".format(reference.text))
self.references_line.insertItem(0, item)
def setValue(self):
self.concept_field.setText(self.concept.name)
self.synonyms_field.setText(self.concept.synonyms)
self.subcategory_field.setText(self.subcategory.subcategory)
self.study_field.setText(self.subcategory.study)
descriptions = self.subcategory.description
for des in descriptions:
item = QListWidgetItem()
item.setData(Qt.UserRole, des)
item.setText("{}".format(des.text))
self.description_field.insertItem(0, item)
def add_feed(self):
title = self.feed_title.text().strip()
if not title:
return error_dialog(self, _('No feed title'), _(
'You must specify a title for the feed'), show=True)
url = self.feed_url.text().strip()
if not title:
return error_dialog(self, _('No feed URL'), _(
'You must specify a URL for the feed'), show=True)
QListWidgetItem('%s - %s' % (title, url), self.feeds).setData(Qt.UserRole, (title, url))
self.feed_title.clear(), self.feed_url.clear()
def refresh(self, idx):
if self.lock_qv.isChecked():
return
bv_row = idx.row()
self.current_column = idx.column()
key = self.view.model().column_map[self.current_column]
book_id = self.view.model().id(bv_row)
if self.current_book_id == book_id and self.current_key == key:
return
# Only show items for categories
if not self.db.field_metadata[key]['is_category']:
if self.current_key is None:
self.indicate_no_items()
return
key = self.current_key
label_text = _('&Item: {0} ({1})')
if self.is_pane:
label_text = label_text.replace('&', '')
self.items_label.setText(
label_text.format(self.db.field_metadata[key]['name'], key))
self.items.blockSignals(True)
self.items.clear()
self.books_table.setRowCount(0)
mi = self.db.get_metadata(book_id,
index_is_id=True,
get_user_categories=False)
vals = mi.get(key, None)
if vals:
self.no_valid_items = False
if self.db.field_metadata[key]['datatype'] == 'rating':
vals = unicode(vals / 2)
if not isinstance(vals, list):
vals = [vals]
vals.sort(key=sort_key)
for v in vals:
a = QListWidgetItem(v)
self.items.addItem(a)
self.items.setCurrentRow(0)
self.current_book_id = book_id
self.current_key = key
self.fill_in_books_box(vals[0])
else:
self.indicate_no_items()
self.items.blockSignals(False)
def initialize(self):
self.devices.blockSignals(True)
self.devices.clear()
for dev in self.gui.device_manager.devices:
for d, name in dev.get_user_blacklisted_devices().iteritems():
item = QListWidgetItem('%s [%s]'%(name, d), self.devices)
item.setData(Qt.UserRole, (dev, d))
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsUserCheckable|Qt.ItemIsSelectable)
item.setCheckState(Qt.Checked)
self.devices.blockSignals(False)
self.device_plugins.blockSignals(True)
for dev in self.gui.device_manager.disabled_device_plugins:
n = dev.get_gui_name()
item = QListWidgetItem(n, self.device_plugins)
item.setData(Qt.UserRole, dev)
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsUserCheckable|Qt.ItemIsSelectable)
item.setCheckState(Qt.Checked)
item.setIcon(QIcon(I('plugins.png')))
self.device_plugins.sortItems()
self.device_plugins.blockSignals(False)
def setResult(self, result, list):
"""This is a universal method for showing information
in a relation field or in a concept field.
"""
list.clear()
for concept, subcategory, *other in result:
item = QListWidgetItem()
item.setData(Qt.UserRole, (concept, subcategory, *other))
item.setText("{}{} {}".format(concept.name,
"" if subcategory.subcategory == "" else ", ",
subcategory.subcategory))
list.insertItem(0, item)
def entry_to_item(entry, parent):
try:
icon = load_icon_resource(entry.get('icon_resource'))
except Exception:
icon = None
import traceback
traceback.print_exc()
if not icon:
icon = entry_to_icon_text(entry)[0]
ans = QListWidgetItem(QIcon(icon), entry.get('name') or _('Unknown'), parent)
ans.setData(ENTRY_ROLE, entry)
ans.setToolTip(_('Command line:') + '\n' + entry['cmdline'])
def addDescription(self):
dlg = EditReferenceOrDescription(
Description(text="", subcategory_id=self.subcategory.id))
dlg.setWindowTitle("Edit description")
if dlg.exec_():
description = dlg.getValue()
self.parent().db.update_description(description)
item = QListWidgetItem()
item.setData(Qt.UserRole, description)
item.setText("{}".format(description.text))
self.description_field.insertItem(0, item)
self.references_field.clear()
def editar_comida_favorita(self):
item_seleccionado = self.ui.lst_comidas_favoritas.currentRow(
) #para recuperar el item a editar
texto, resultado = QInputDialog.getText(self, "Editar comida favorita",
"Agregue el nuevo nombre")
if resultado and (len(texto) != 0):
self.ui.lst_comidas_favoritas.takeItem(
self.ui.lst_comidas_favoritas.currentRow())
self.ui.lst_comidas_favoritas.insertItem(item_seleccionado,
QListWidgetItem(texto))
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = QVBoxLayout(self)
self.splitter = l = QSplitter(self)
l.setChildrenCollapsible(False)
self.layout().addWidget(l)
self.reports = r = QListWidget(self)
l.addWidget(r)
self.stack = s = QStackedWidget(self)
l.addWidget(s)
r.currentRowChanged.connect(s.setCurrentIndex)
self.files = f = FilesWidget(self)
f.edit_requested.connect(self.edit_requested)
f.delete_requested.connect(self.delete_requested)
s.addWidget(f)
QListWidgetItem(_('Files'), r)
self.words = w = WordsWidget(self)
s.addWidget(w)
QListWidgetItem(_('Words'), r)
self.images = i = ImagesWidget(self)
i.edit_requested.connect(self.edit_requested)
i.delete_requested.connect(self.delete_requested)
s.addWidget(i)
QListWidgetItem(_('Images'), r)
self.css = c = CSSWidget(self)
s.addWidget(c)
QListWidgetItem(_('Style Rules'), r)
self.css = c = ClassesWidget(self)
s.addWidget(c)
QListWidgetItem(_('Style Classes'), r)
self.chars = c = CharsWidget(self)
s.addWidget(c)
QListWidgetItem(_('Characters'), r)
self.links = li = LinksWidget(self)
s.addWidget(li)
QListWidgetItem(_('Links'), r)
self.splitter.setStretchFactor(1, 500)
try:
self.splitter.restoreState(read_state('splitter-state'))
except TypeError:
pass
current_page = read_state('report-page')
if current_page is not None:
self.reports.setCurrentRow(current_page)
self.layout().setContentsMargins(0, 0, 0, 0)
for i in xrange(self.stack.count()):
self.stack.widget(i).layout().setContentsMargins(0, 0, 0, 0)
def run(self):
self.Active = True
self.paused = False
# Counter variable for number of packets sent.
self.packet_counter = 0
while self.packet_counter <= self.num_lines:
if not self.paused:
# Current speed of the simulation, 1 is normal, 2 is twice as fast, etc.
self.speed = self.ui.sim_speed.value()
# The higher the speed, the more packets are skipped over.
if not ((self.packet_counter % self.speed) == 0):
self.packet_counter += 1
continue
self.advanceSim(self.all_lines[self.packet_counter])
self.packet_counter += 1
#self.console.scrollToBottom()
else:
time.sleep(0.25)
# Inform the user that the simulation has finished and wait for them to press enter and exit.
self.console.addItem(QListWidgetItem(''))
self.console.addItem(QListWidgetItem('NFF simulation completed!'))
def re_sort(self):
self.themes.sort(key=lambda x:sort_key(x.get('title', '')))
field = self.sort_on
if field == 'number':
self.themes.sort(key=lambda x:x.get('number', 0), reverse=True)
elif field == 'usage':
self.themes.sort(key=lambda x:self.usage.get(x.get('name'), 0), reverse=True)
self.theme_list.clear()
for theme in self.themes:
i = QListWidgetItem(theme.get('title', '') + ' %s %s' % (theme.get('number'), self.usage.get(theme.get('name'))), self.theme_list)
i.setData(Qt.UserRole, theme)
if 'cover-pixmap' in theme:
i.setData(Qt.DecorationRole, theme['cover-pixmap'])
def init_input_order(self, defaults=False):
if defaults:
input_map = prefs.defaults['input_format_order']
else:
input_map = prefs['input_format_order']
all_formats = set()
self.opt_input_order.clear()
for fmt in all_input_formats().union({'ZIP', 'RAR'}):
all_formats.add(fmt.upper())
for format in input_map + list(all_formats.difference(input_map)):
item = QListWidgetItem(format, self.opt_input_order)
item.setData(Qt.UserRole, (format))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
def editar_tratamientos(self):
item_editar = self.ui.lst_tratamientos.currentRow(
) #selecciona el elemento de la fila seleccionada
#da 2 variables, una para el texo que se ponga y otra para crear un input
texto, resultado = QInputDialog.getText(self, "Ingresar",
"Ingresar nuevo tratamiento ")
if resultado == True and (len(texto) != 0):
self.ui.lst_tratamientos.takeItem(item_editar) #quita ese item
self.ui.lst_tratamientos.insertItem(
item_editar,
QListWidgetItem(texto)) #añade nuevo item en esa fila
def load(self, highlights):
self.clear()
self.uuid_map = {}
highlights = (h for h in highlights
if not h.get('removed') and h.get('highlighted_text'))
for h in self.sorted_highlights(highlights):
txt = h.get('highlighted_text')
txt = txt.replace('\n', ' ')
if len(txt) > 100:
txt = txt[:100] + '…'
i = QListWidgetItem(txt, self)
i.setData(Qt.UserRole, h)
self.uuid_map[h['uuid']] = self.count() - 1
def initialize(self, catalog_name, db):
self.name = catalog_name
from calibre.library.catalogs import FIELDS
db = get_gui().current_db
self.all_fields = {x
for x in FIELDS
if x != 'all'} | set(db.custom_field_keys())
sort_order = gprefs.get(self.name + '_db_fields_sort_order', {})
fm = db.field_metadata
def name(x):
if x == 'isbn':
return 'ISBN'
if x == 'library_name':
return _('Library name')
if x.endswith('_index'):
return name(x[:-len('_index')]) + ' ' + _('Number')
return fm[x].get('name') or x
def key(x):
return (sort_order.get(x, 10000), name(x))
self.db_fields.clear()
for x in sorted(self.all_fields, key=key):
QListWidgetItem(name(x) + ' (%s)' % x,
self.db_fields).setData(Qt.UserRole, x)
if x.startswith('#') and fm[x]['datatype'] == 'series':
x += '_index'
QListWidgetItem(name(x) + ' (%s)' % x,
self.db_fields).setData(Qt.UserRole, x)
# Restore the activated fields from last use
fields = frozenset(
gprefs.get(self.name + '_db_fields', self.all_fields))
for x in range(self.db_fields.count()):
item = self.db_fields.item(x)
item.setCheckState(Qt.Checked if unicode(item.data(Qt.UserRole)) in
fields else Qt.Unchecked)
def link_stylesheets(self, names):
s = self.categories['styles']
sheets = [
unicode(s.child(i).data(0, NAME_ROLE) or '')
for i in xrange(s.childCount())
]
if not sheets:
return error_dialog(
self,
_('No stylesheets'),
_('This book currently has no stylesheets. You must first create a stylesheet'
' before linking it.'),
show=True)
d = QDialog(self)
d.l = l = QVBoxLayout(d)
d.setLayout(l)
d.setWindowTitle(_('Choose stylesheets'))
d.la = la = QLabel(
_('Choose the stylesheets to link. Drag and drop to re-arrange'))
la.setWordWrap(True)
l.addWidget(la)
d.s = s = QListWidget(d)
l.addWidget(s)
s.setDragEnabled(True)
s.setDropIndicatorShown(True)
s.setDragDropMode(self.InternalMove)
s.setAutoScroll(True)
s.setDefaultDropAction(Qt.MoveAction)
for name in sheets:
i = QListWidgetItem(name, s)
flags = Qt.ItemIsEnabled | Qt.ItemIsUserCheckable | Qt.ItemIsDragEnabled | Qt.ItemIsSelectable
i.setFlags(flags)
i.setCheckState(Qt.Checked)
d.r = r = QCheckBox(_('Remove existing links to stylesheets'))
r.setChecked(tprefs['remove_existing_links_when_linking_sheets'])
l.addWidget(r)
d.bb = bb = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
bb.accepted.connect(d.accept), bb.rejected.connect(d.reject)
l.addWidget(bb)
if d.exec_() == d.Accepted:
tprefs['remove_existing_links_when_linking_sheets'] = r.isChecked()
sheets = [
unicode(s.item(il).text()) for il in xrange(s.count())
if s.item(il).checkState() == Qt.Checked
]
if sheets:
self.link_stylesheets_requested.emit(names, sheets,
r.isChecked())
def set_qpb_list_item(self, channel_id, lbp):
item = QListWidgetItem(self.qpb_list_widget)
item.setSizeHint(QSize(400, 80))
widget = QWidget(self.qpb_list_widget)
v_layout = QVBoxLayout()
label = QLabel(channel_id + "==>>>等待出包...")
v_layout.addWidget(label)
lbp['label'] = label
qpb = QProgressBar(self.qpb_list_widget)
v_layout.addWidget(qpb)
lbp['qpb'] = qpb
widget.setLayout(v_layout)
self.qpb_list_widget.addItem(item)
self.qpb_list_widget.setItemWidget(item, widget)
def addReference(self):
if self.description_field.currentIndex().isValid():
description_id = self.description_field.selectedItems()[0].data(
Qt.UserRole).id
dialog = NewReferenceDialog(self.parent().db, ConceptReference)
if dialog.exec_():
references = dialog.getValues()
for reference in references:
reference.node_id = description_id
self.parent().db.commit(reference)
item = QListWidgetItem()
item.setData(Qt.UserRole, reference)
item.setText("{}".format(reference.text))
self.references_field.insertItem(0, item)
def _refillData(self):
widget = self.widget
oldBlockSignals = widget.blockSignals(True)
oldAutoScroll = widget.hasAutoScroll()
widget.setAutoScroll(False)
# Scroll preserving code. From
# https://stackoverflow.com/questions/34237006/qlistview-how-to-automatically-scroll-the-view-and-keep-current-selection-on-co
vScrollBar = widget.verticalScrollBar()
previousViewTopRow = widget.indexAt(QPoint(4, 4)).row()
hasScrolledToBottom = vScrollBar.value() == vScrollBar.maximum()
oldSelect = self.select()
if oldSelect is None:
oldSelect = []
elif not self._multiselect:
oldSelect = [oldSelect]
widget.clear()
for d in self._data:
item = QListWidgetItem()
item.setText(self._renderer(d))
item.setData(Qt.UserRole, d)
widget.addItem(item)
if d in oldSelect:
item.setSelected(True)
if self._sorted:
widget.sortItems()
widget.scrollToTop()
topIndex = widget.indexAt(QPoint(4, 4))
widget.setAutoScroll(
oldAutoScroll
) # Re-enable autoscroll before scrolling to appropriate position
if hasScrolledToBottom:
widget.scrollToBottom()
else:
widget.scrollTo(topIndex.sibling(previousViewTopRow, 0),
QAbstractItemView.PositionAtTop)
widget.blockSignals(oldBlockSignals)
# Actually we should check that same set of items were selected before & after the change,
# but widget only selects less when underlying data changes, so no more data could be
# selected any other than oldSelect. So it's sufficient to only check the length to
# see if two list are same irrespective of orderings.
if len(widget.selectedItems()) != len(oldSelect):
self.widget.itemSelectionChanged.emit()
def _refresh(self, book_id, key):
'''
Actually fill in the left-hand pane from the information in the
selected column of the selected book
'''
# Only show items for categories
if key is None or not self.fm[key]['is_category']:
if self.current_key is None:
self.indicate_no_items()
return
key = self.current_key
label_text = _('&Item: {0} ({1})')
if self.is_pane:
label_text = label_text.replace('&', '')
self.items_label.setText(label_text.format(self.fm[key]['name'], key))
self.items.blockSignals(True)
self.items.clear()
self.books_table.setRowCount(0)
mi = self.db.get_metadata(book_id,
index_is_id=True,
get_user_categories=False)
vals = mi.get(key, None)
if vals:
self.no_valid_items = False
if self.fm[key]['datatype'] == 'rating':
if self.fm[key]['display'].get('allow_half_stars', False):
vals = unicode(vals / 2.0)
else:
vals = unicode(vals / 2)
if not isinstance(vals, list):
vals = [vals]
vals.sort(key=sort_key)
for v in vals:
a = QListWidgetItem(v)
self.items.addItem(a)
self.items.setCurrentRow(0)
self.current_book_id = book_id
self.current_key = key
self.fill_in_books_box(vals[0])
else:
self.indicate_no_items()
self.items.blockSignals(False)
def refresh_target_note_type_listWidget(self, select_model_id=""):
row_to_select = 0
self.target_note_type_listWidget.clear()
if self.target_model_id_list:
self.target_model_id_list.sort()
for model_id in self.target_model_id_list:
if model_id not in self.all_model_id_list:
self.target_model_id_list.remove(model_id)
for model_id in self.target_model_id_list:
item = QListWidgetItem("%s" % self.model_manager.get(model_id)["name"])
self.target_note_type_listWidget.addItem(item)
if model_id == select_model_id:
row_to_select = self.target_model_id_list.index(model_id)
self.target_note_type_listWidget.setCurrentRow(row_to_select)
