def setup_ui(self):
DELETE_STR = _('Delete')
MODIFY_STR = _('Modify')
NO_ATTRIB_STR = _('No attributes ("naked" tag)')
self.NO_CHANGE_STR = _('No change')
layout = QVBoxLayout(self)
self.setLayout(layout)
help_layout = QHBoxLayout()
layout.addLayout(help_layout)
# Add hyperlink to a help file at the right. We will replace the correct name when it is clicked.
help_label = QLabel('<a href="http://www.foo.com/">Plugin Help</a>',
self)
help_label.setTextInteractionFlags(Qt.LinksAccessibleByMouse
| Qt.LinksAccessibleByKeyboard)
help_label.setAlignment(Qt.AlignRight)
help_label.linkActivated.connect(self.help_link_activated)
help_layout.addWidget(help_label)
action_layout = QHBoxLayout()
layout.addLayout(action_layout)
label = QLabel(_('Action type:'), self)
action_layout.addWidget(label)
self.action_combo = QComboBox()
action_layout.addWidget(self.action_combo)
self.action_combo.addItems([DELETE_STR, MODIFY_STR])
self.action_combo.currentIndexChanged.connect(self.update_gui)
tag_layout = QHBoxLayout()
layout.addLayout(tag_layout)
label = QLabel(_('Tag name:'), self)
tag_layout.addWidget(label)
self.tag_combo = QComboBox()
tag_layout.addWidget(self.tag_combo)
self.tag_combo.addItems(self.taglist)
self.tag_combo.currentIndexChanged.connect(self.update_gui)
attr_layout = QHBoxLayout()
layout.addLayout(attr_layout)
label = QLabel(_('Having the attribute:'), self)
attr_layout.addWidget(label)
self.attr_combo = QComboBox()
attr_layout.addWidget(self.attr_combo)
self.attr_combo.addItems(self.prefs['attrs'])
self.attr_combo.addItem(NO_ATTRIB_STR)
self.attr_combo.currentIndexChanged.connect(self.update_gui)
srch_layout = QHBoxLayout()
layout.addLayout(srch_layout)
label = QLabel(_("Whose value is (no quotes):"), self)
srch_layout.addWidget(label)
self.srch_txt = QLineEdit('', self)
srch_layout.addWidget(self.srch_txt)
self.srch_method = QCheckBox(_('Regex'), self)
srch_layout.addWidget(self.srch_method)
newtag_layout = QHBoxLayout()
layout.addLayout(newtag_layout)
label = QLabel(_('Change tag to:'), self)
newtag_layout.addWidget(label)
self.newtag_combo = QComboBox()
newtag_layout.addWidget(self.newtag_combo)
self.newtag_combo.addItem(self.NO_CHANGE_STR)
self.newtag_combo.addItems(self.prefs['{}_changes'.format(
unicode(self.tag_combo.currentText()))])
if self.action_combo.currentIndex() == 0:
self.newtag_combo.setDisabled(True)
newattr_layout = QVBoxLayout()
layout.addLayout(newattr_layout)
label = QLabel(_('New attribute string to insert (entire):'), self)
newattr_layout.addWidget(label)
self.newattr_txt = QLineEdit('', self)
newattr_layout.addWidget(self.newattr_txt)
self.copy_attr = QCheckBox(_('Copy existing attribute string'), self)
self.copy_attr.stateChanged.connect(self.update_txt_box)
newattr_layout.addWidget(self.copy_attr)
if self.action_combo.currentIndex() == 0:
self.copy_attr.setDisabled(True)
self.newattr_txt.setDisabled(True)
layout.addSpacing(10)
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self._ok_clicked)
button_box.rejected.connect(self.reject)
layout.addWidget(button_box)
def setup_ui(self): # {{{
self.setWindowModality(Qt.ApplicationModal)
self.setWindowIcon(QIcon(I('column.png')))
self.vl = l = QVBoxLayout(self)
self.heading_label = la = QLabel('')
l.addWidget(la)
self.shortcuts = s = QLabel('')
s.setWordWrap(True)
s.linkActivated.connect(self.shortcut_activated)
text = '<p>' + _('Quick create:')
for col, name in [('isbn', _('ISBN')), ('formats', _('Formats')),
('yesno', _('Yes/No')), ('tags', _('Tags')),
('series', _('Series')), ('rating', _('Rating')),
('people', _("Names")), ('text', _('Short text'))]:
text += ' <a href="col:%s">%s</a>,' % (col, name)
text = text[:-1]
s.setText(text)
l.addWidget(s)
self.g = g = QGridLayout()
l.addLayout(g)
l.addStretch(10)
self.button_box = bb = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self)
bb.accepted.connect(self.accept), bb.rejected.connect(self.reject)
l.addWidget(bb)
def add_row(text, widget):
if text is None:
f = g.addWidget if isinstance(widget, QWidget) else g.addLayout
f(widget, g.rowCount(), 0, 1, -1)
return
row = g.rowCount()
la = QLabel(text)
g.addWidget(la, row, 0, 1, 1)
if isinstance(widget, QWidget):
la.setBuddy(widget)
g.addWidget(widget, row, 1, 1, 1)
else:
widget.setContentsMargins(0, 0, 0, 0)
g.addLayout(widget, row, 1, 1, 1)
for i in range(widget.count()):
w = widget.itemAt(i).widget()
if isinstance(w, QWidget):
la.setBuddy(w)
break
return la
# Lookup name
self.column_name_box = cnb = QLineEdit(self)
cnb.setToolTip(
_("Used for searching the column. Must contain only digits and lower case letters."
))
add_row(_("&Lookup name"), cnb)
# Heading
self.column_heading_box = chb = QLineEdit(self)
chb.setToolTip(
_("Column heading in the library view and category name in the tag browser"
))
add_row(_("Column &heading"), chb)
# Column Type
h = QHBoxLayout()
self.column_type_box = ctb = QComboBox(self)
ctb.setMinimumWidth(70)
ctb.setToolTip(
_("What kind of information will be kept in the column."))
h.addWidget(ctb)
self.use_decorations = ud = QCheckBox(_("Show &checkmarks"), self)
ud.setToolTip(
_("Show check marks in the GUI. Values of 'yes', 'checked', and 'true'\n"
"will show a green check. Values of 'no', 'unchecked', and 'false' will show a red X.\n"
"Everything else will show nothing."))
h.addWidget(ud)
self.is_names = ins = QCheckBox(_("Contains names"), self)
ins.setToolTip(
_("Check this box if this column contains names, like the authors column."
))
h.addWidget(ins)
add_row(_("&Column type"), h)
# Description
self.description_box = d = QLineEdit(self)
d.setToolTip(_("Optional text describing what this column is for"))
add_row(_("D&escription"), d)
# Date/number formatting
h = QHBoxLayout()
self.format_box = fb = QLineEdit(self)
h.addWidget(fb)
self.format_default_label = la = QLabel('')
la.setOpenExternalLinks(True)
h.addWidget(la)
self.format_label = add_row('', h)
# Template
self.composite_box = cb = QLineEdit(self)
self.composite_default_label = cdl = QLabel(_("Default: (nothing)"))
cb.setToolTip(
_("Field template. Uses the same syntax as save templates."))
cdl.setToolTip(
_("Similar to save templates. For example, %s") % "{title} {isbn}")
h = QHBoxLayout()
h.addWidget(cb), h.addWidget(cdl)
self.composite_label = add_row(_("&Template"), h)
# Comments properties
self.comments_heading_position = ct = QComboBox(self)
for k, text in (('hide', _('No heading')),
('above', _('Show heading above the text')),
('side', _('Show heading to the side of the text'))):
ct.addItem(text, k)
ct.setToolTip(
_('Choose whether or not the column heading is shown in the Book\n'
'Details panel and, if shown, where'))
self.comments_heading_position_label = add_row(_('Column heading'), ct)
self.comments_type = ct = QComboBox(self)
for k, text in (('html', 'HTML'), ('short-text',
_('Short text, like a title')),
('long-text', _('Plain text')),
('markdown',
_('Plain text formatted using markdown'))):
ct.addItem(text, k)
ct.setToolTip(
_('Choose how the data in this column is interpreted.\n'
'This controls how the data is displayed in the Book Details panel\n'
'and how it is edited.'))
self.comments_type_label = add_row(
_('Interpret this column as:') + ' ', ct)
# Values for enum type
l = QGridLayout()
self.enum_box = eb = QLineEdit(self)
eb.setToolTip(
_("A comma-separated list of permitted values. The empty value is always\n"
"included, and is the default. For example, the list 'one,two,three' has\n"
"four values, the first of them being the empty value."))
self.enum_default_label = la = QLabel(_("Values"))
la.setBuddy(eb)
l.addWidget(eb), l.addWidget(la, 0, 1)
self.enum_colors = ec = QLineEdit(self)
ec.setToolTip(
_("A list of color names to use when displaying an item. The\n"
"list must be empty or contain a color for each value."))
self.enum_colors_label = la = QLabel(_('Colors'))
la.setBuddy(ec)
l.addWidget(ec), l.addWidget(la, 1, 1)
self.enum_label = add_row(_('&Values'), l)
# Rating allow half stars
self.allow_half_stars = ahs = QCheckBox(_('Allow half stars'))
ahs.setToolTip(
_('Allow half star ratings, for example: ') +
'<span style="font-family:calibre Symbols">★★★½</span>')
add_row(None, ahs)
# Composite display properties
l = QHBoxLayout()
self.composite_sort_by_label = la = QLabel(_("&Sort/search column by"))
self.composite_sort_by = csb = QComboBox(self)
la.setBuddy(csb), csb.setToolTip(
_("How this column should handled in the GUI when sorting and searching"
))
l.addWidget(la), l.addWidget(csb)
self.composite_make_category = cmc = QCheckBox(
_("Show in tags browser"))
cmc.setToolTip(
_("If checked, this column will appear in the tags browser as a category"
))
l.addWidget(cmc)
self.composite_contains_html = cch = QCheckBox(
_("Show as HTML in book details"))
cch.setToolTip(
'<p>' +
_('If checked, this column will be displayed as HTML in '
'book details and the content server. This can be used to '
'construct links with the template language. For example, '
'the template '
'<pre><big><b>{title}</b></big>'
'{series:| [|}{series_index:| [|]]}</pre>'
'will create a field displaying the title in bold large '
'characters, along with the series, for example <br>"<big><b>'
'An Oblique Approach</b></big> [Belisarius [1]]". The template '
'<pre><a href="https://www.beam-ebooks.de/ebook/{identifiers'
':select(beam)}">Beam book</a></pre> '
'will generate a link to the book on the Beam ebooks site.') +
'</p>')
l.addWidget(cch)
add_row(None, l)
self.resize(self.sizeHint())
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = gl = QGridLayout(self)
self.changed = False
self.bars = b = QComboBox(self)
b.addItem(_('Choose which toolbar you want to customize'))
ft = _('Tools for %s editors')
for name, text in (
(
'global_book_toolbar',
_('Book wide actions'),
),
(
'global_tools_toolbar',
_('Book wide tools'),
),
(
'global_plugins_toolbar',
_('Book wide tools from third party plugins'),
),
('editor_common_toolbar', ft % _('all')),
(
'editor_html_toolbar',
ft % 'HTML',
),
(
'editor_css_toolbar',
ft % 'CSS',
),
(
'editor_xml_toolbar',
ft % 'XML',
),
(
'editor_format_toolbar',
_('Text formatting actions'),
),
):
b.addItem(text, name)
self.la = la = QLabel(_('&Toolbar to customize:'))
la.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
la.setBuddy(b)
gl.addWidget(la), gl.addWidget(b, 0, 1)
self.sl = l = QGridLayout()
gl.addLayout(l, 1, 0, 1, -1)
self.gb1 = gb1 = QGroupBox(_('A&vailable actions'), self)
self.gb2 = gb2 = QGroupBox(_('&Current actions'), self)
gb1.setFlat(True), gb2.setFlat(True)
gb1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
gb2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
l.addWidget(gb1, 0, 0, -1, 1), l.addWidget(gb2, 0, 2, -1, 1)
self.available, self.current = ToolbarList(self), ToolbarList(self)
self.ub = b = QToolButton(self)
connect_lambda(b.clicked, self, lambda self: self.move(up=True))
b.setToolTip(_('Move selected action up')), b.setIcon(
QIcon(I('arrow-up.png')))
self.db = b = QToolButton(self)
connect_lambda(b.clicked, self, lambda self: self.move(up=False))
b.setToolTip(_('Move selected action down')), b.setIcon(
QIcon(I('arrow-down.png')))
self.gl1 = gl1 = QVBoxLayout()
gl1.addWidget(self.available), gb1.setLayout(gl1)
self.gl2 = gl2 = QGridLayout()
gl2.addWidget(self.current, 0, 0, -1, 1)
gl2.addWidget(self.ub, 0, 1), gl2.addWidget(self.db, 2, 1)
gb2.setLayout(gl2)
self.lb = b = QToolButton(self)
b.setToolTip(_('Add selected actions to the toolbar')), b.setIcon(
QIcon(I('forward.png')))
l.addWidget(b, 1, 1), b.clicked.connect(self.add_action)
self.rb = b = QToolButton(self)
b.setToolTip(_('Remove selected actions from the toolbar')), b.setIcon(
QIcon(I('back.png')))
l.addWidget(b, 3, 1), b.clicked.connect(self.remove_action)
self.si = QSpacerItem(20,
10,
hPolicy=QSizePolicy.Preferred,
vPolicy=QSizePolicy.Expanding)
l.setRowStretch(0, 10), l.setRowStretch(2, 10), l.setRowStretch(4, 10)
l.addItem(self.si, 4, 1)
self.read_settings()
self.toggle_visibility(False)
self.bars.currentIndexChanged.connect(self.bar_changed)
self.toolbar_icon_size = ics = QSpinBox(self)
ics.setMinimum(16), ics.setMaximum(128), ics.setSuffix(
' px'), ics.setValue(tprefs['toolbar_icon_size'])
ics.setToolTip('<p>' + _('Adjust the size of icons on all toolbars'))
self.h = h = QHBoxLayout()
gl.addLayout(h, gl.rowCount(), 0, 1, -1)
self.toolbar_icon_size_label = la = QLabel(_('Toolbar &icon size:'))
la.setBuddy(ics)
h.addWidget(la), h.addWidget(ics), h.addStretch(10)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QVBoxLayout(self)
self.h = h = QHBoxLayout()
self.la = la = QLabel(self.MSG)
la.setWordWrap(True)
l.addWidget(la)
l.addLayout(h)
english_sentence = '{preamble} {property} {match_type} {query}'
sentence = _('{preamble} {property} {match_type} {query}')
if set(sentence.split()) != set(english_sentence.split()):
sentence = english_sentence
parts = sentence.split()
for clause in parts:
if clause == '{preamble}':
self.preamble = w = QLabel(_('If the &property:'))
elif clause == '{property}':
self.property = w = QLineEdit(self)
w.setToolTip(
_('The name of a CSS property, for example: font-size\n'
'Do not use shorthand properties, they will not work.\n'
'For instance use margin-top, not margin.'))
elif clause == '{match_type}':
self.match_type = w = QComboBox(self)
for action, text in iteritems(MATCH_TYPE_MAP):
w.addItem(text, action)
w.currentIndexChanged.connect(self.update_state)
elif clause == '{query}':
self.query = w = QLineEdit(self)
h.addWidget(w)
if clause is not parts[-1]:
h.addWidget(QLabel('\xa0'))
self.preamble.setBuddy(self.property)
self.h2 = h = QHBoxLayout()
l.addLayout(h)
english_sentence = '{action} {action_data}'
sentence = _('{action} {action_data}')
if set(sentence.split()) != set(english_sentence.split()):
sentence = english_sentence
parts = sentence.split()
for clause in parts:
if clause == '{action}':
self.action = w = QComboBox(self)
for action, text in iteritems(ACTION_MAP):
w.addItem(text, action)
w.currentIndexChanged.connect(self.update_state)
elif clause == '{action_data}':
self.action_data = w = QLineEdit(self)
h.addWidget(w)
if clause is not parts[-1]:
h.addWidget(QLabel('\xa0'))
self.regex_help = la = QLabel(
'<p>' + RE.REGEXP_HELP_TEXT % localize_user_manual_link(
'https://manual.calibre-ebook.com/regexp.html'))
la.setOpenExternalLinks(True)
la.setWordWrap(True)
l.addWidget(la)
l.addStretch(10)
self.update_state()
def setup_ui(self):
self.vl = vl = QVBoxLayout(self)
self.stack = l = QStackedLayout()
self.pi = pi = ProgressIndicator(self, 256)
vl.addLayout(l), vl.addWidget(self.bb)
self.restore_defs_button = b = self.bb.addButton(
_('Restore &default icons'), self.bb.ActionRole)
b.clicked.connect(self.restore_defaults)
b.setIcon(QIcon(I('view-refresh.png')))
self.c = c = QWidget(self)
self.c.v = v = QVBoxLayout(self.c)
v.addStretch(), v.addWidget(pi, 0, Qt.AlignCenter)
self.wait_msg = m = QLabel(self)
v.addWidget(m, 0, Qt.AlignCenter), v.addStretch()
f = m.font()
f.setBold(True), f.setPointSize(28), m.setFont(f)
self.start_spinner()
l.addWidget(c)
self.w = w = QWidget(self)
l.addWidget(w)
w.l = l = QGridLayout(w)
def add_row(x, y=None):
if isinstance(x, type('')):
x = QLabel(x)
row = l.rowCount()
if y is None:
if isinstance(x, QLabel):
x.setWordWrap(True)
l.addWidget(x, row, 0, 1, 2)
else:
if isinstance(x, QLabel):
x.setBuddy(y)
l.addWidget(x, row, 0), l.addWidget(y, row, 1)
add_row(
_('Choose an icon theme below. You will need to restart'
' calibre to see the new icons.'))
add_row(
_('Current icon theme:') + '\xa0<b>' +
(self.current_theme or 'None'))
self.sort_by = sb = QComboBox(self)
add_row(_('&Sort by:'), sb)
sb.addItems([
_('Number of icons'),
_('Popularity'),
_('Name'),
])
sb.setEditable(False), sb.setCurrentIndex(
gprefs.get('choose_icon_theme_sort_by', 1))
sb.currentIndexChanged[int].connect(self.re_sort)
sb.currentIndexChanged[int].connect(
lambda: gprefs.set('choose_icon_theme_sort_by', sb.currentIndex()))
self.theme_list = tl = QListWidget(self)
tl.setVerticalScrollMode(tl.ScrollPerPixel)
self.delegate = Delegate(tl)
tl.setItemDelegate(self.delegate)
tl.itemDoubleClicked.connect(self.accept)
add_row(tl)
t = Thread(name='GetIconThemes', target=self.get_themes)
t.daemon = True
t.start()
def __init__(self, opts):
self.matched_ids = set()
self.opts = opts
self.prefs = opts.prefs
super(FindAnnotationsDialog, self).__init__(self.opts.gui, 'find_annotations_dialog')
self.setWindowTitle(_('Find Annotations'))
self.setWindowIcon(self.opts.icon)
self.l = QVBoxLayout(self)
self.setLayout(self.l)
self.search_criteria_gb = QGroupBox(self)
self.search_criteria_gb.setTitle(_("Search criteria"))
self.scgl = QGridLayout(self.search_criteria_gb)
self.l.addWidget(self.search_criteria_gb)
# addWidget(widget, row, col, rowspan, colspan)
row = 0
# ~~~~~~~~ Create the Readers comboBox ~~~~~~~~
self.reader_label = QLabel(_('Reader'))
self.reader_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.reader_label, row, 0, 1, 1)
self.find_annotations_reader_comboBox = QComboBox()
self.find_annotations_reader_comboBox.setObjectName('find_annotations_reader_comboBox')
self.find_annotations_reader_comboBox.setToolTip(_('Reader annotations to search for'))
self.find_annotations_reader_comboBox.addItem(self.GENERIC_READER)
racs = ReaderApp.get_reader_app_classes()
for ra in sorted(racs.keys()):
self.find_annotations_reader_comboBox.addItem(ra)
self.scgl.addWidget(self.find_annotations_reader_comboBox, row, 1, 1, 4)
row += 1
# ~~~~~~~~ Create the Styles comboBox ~~~~~~~~
self.style_label = QLabel(_('Style'))
self.style_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.style_label, row, 0, 1, 1)
self.find_annotations_color_comboBox = QComboBox()
self.find_annotations_color_comboBox.setObjectName('find_annotations_color_comboBox')
self.find_annotations_color_comboBox.setToolTip(_('Annotation style to search for'))
self.find_annotations_color_comboBox.addItem(self.GENERIC_STYLE)
all_colors = COLOR_MAP.keys()
all_colors.remove('Default')
for color in sorted(all_colors):
self.find_annotations_color_comboBox.addItem(color)
self.scgl.addWidget(self.find_annotations_color_comboBox, row, 1, 1, 4)
row += 1
# ~~~~~~~~ Create the Text LineEdit control ~~~~~~~~
self.text_label = QLabel(_('Text'))
self.text_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.text_label, row, 0, 1, 1)
self.find_annotations_text_lineEdit = MyLineEdit()
self.find_annotations_text_lineEdit.setObjectName('find_annotations_text_lineEdit')
self.scgl.addWidget(self.find_annotations_text_lineEdit, row, 1, 1, 3)
self.reset_text_tb = QToolButton()
self.reset_text_tb.setObjectName('reset_text_tb')
self.reset_text_tb.setToolTip(_('Clear search criteria'))
self.reset_text_tb.setIcon(QIcon(I('trash.png')))
self.reset_text_tb.clicked.connect(self.clear_text_field)
self.scgl.addWidget(self.reset_text_tb, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create the Note LineEdit control ~~~~~~~~
self.note_label = QLabel(_('Note'))
self.note_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.note_label, row, 0, 1, 1)
self.find_annotations_note_lineEdit = MyLineEdit()
self.find_annotations_note_lineEdit.setObjectName('find_annotations_note_lineEdit')
self.scgl.addWidget(self.find_annotations_note_lineEdit, row, 1, 1, 3)
self.reset_note_tb = QToolButton()
self.reset_note_tb.setObjectName('reset_note_tb')
self.reset_note_tb.setToolTip(_('Clear search criteria'))
self.reset_note_tb.setIcon(QIcon(I('trash.png')))
self.reset_note_tb.clicked.connect(self.clear_note_field)
self.scgl.addWidget(self.reset_note_tb, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create the Date range controls ~~~~~~~~
self.date_range_label = QLabel(_('Date range'))
self.date_range_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.date_range_label, row, 0, 1, 1)
# Date 'From'
self.find_annotations_date_from_dateEdit = MyDateEdit(self, datetime(1970,1,1))
self.find_annotations_date_from_dateEdit.setObjectName('find_annotations_date_from_dateEdit')
#self.find_annotations_date_from_dateEdit.current_val = datetime(1970,1,1)
self.find_annotations_date_from_dateEdit.clear_button.clicked.connect(self.find_annotations_date_from_dateEdit.reset_from_date)
self.scgl.addWidget(self.find_annotations_date_from_dateEdit, row, 1, 1, 1)
self.scgl.addWidget(self.find_annotations_date_from_dateEdit.clear_button, row, 2, 1, 1)
# Date 'To'
self.find_annotations_date_to_dateEdit = MyDateEdit(self, datetime.today())
self.find_annotations_date_to_dateEdit.setObjectName('find_annotations_date_to_dateEdit')
#self.find_annotations_date_to_dateEdit.current_val = datetime.today()
self.find_annotations_date_to_dateEdit.clear_button.clicked.connect(self.find_annotations_date_to_dateEdit.reset_to_date)
self.scgl.addWidget(self.find_annotations_date_to_dateEdit, row, 3, 1, 1)
self.scgl.addWidget(self.find_annotations_date_to_dateEdit.clear_button, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create a horizontal line ~~~~~~~~
self.hl = QFrame(self)
self.hl.setGeometry(QRect(0, 0, 1, 3))
self.hl.setFrameShape(QFrame.HLine)
self.hl.setFrameShadow(QFrame.Raised)
self.scgl.addWidget(self.hl, row, 0, 1, 5)
row += 1
# ~~~~~~~~ Create the results label field ~~~~~~~~
self.result_label = QLabel('<p style="color:red">{0}</p>'.format(_('scanning…')))
self.result_label.setAlignment(Qt.AlignCenter)
self.result_label.setWordWrap(False)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.result_label.sizePolicy().hasHeightForWidth())
self.result_label.setSizePolicy(sizePolicy)
self.result_label.setMinimumSize(QtCore.QSize(250, 0))
self.scgl.addWidget(self.result_label, row, 0, 1, 5)
row += 1
# ~~~~~~~~ Create the ButtonBox ~~~~~~~~
self.dialogButtonBox = QDialogButtonBox(self)
self.dialogButtonBox.setOrientation(Qt.Horizontal)
if False:
self.update_button = QPushButton(_('Update results'))
self.update_button.setDefault(True)
self.update_button.setVisible(False)
self.dialogButtonBox.addButton(self.update_button, QDialogButtonBox.ActionRole)
self.cancel_button = self.dialogButtonBox.addButton(self.dialogButtonBox.Cancel)
self.find_button = self.dialogButtonBox.addButton(self.dialogButtonBox.Ok)
self.find_button.setText(_('Find Matching Books'))
self.l.addWidget(self.dialogButtonBox)
self.dialogButtonBox.clicked.connect(self.find_annotations_dialog_clicked)
# ~~~~~~~~ Add a spacer ~~~~~~~~
self.spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.l.addItem(self.spacerItem)
# ~~~~~~~~ Restore previously saved settings ~~~~~~~~
self.restore_settings()
# ~~~~~~~~ Declare sizing ~~~~~~~~
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
self.resize_dialog()
# ~~~~~~~~ Connect all signals ~~~~~~~~
self.find_annotations_reader_comboBox.currentIndexChanged.connect(partial(self.update_results, 'reader'))
self.find_annotations_color_comboBox.currentIndexChanged.connect(partial(self.update_results, 'color'))
self.find_annotations_text_lineEdit.editingFinished.connect(partial(self.update_results, 'text'))
self.find_annotations_note_lineEdit.editingFinished.connect(partial(self.update_results, 'note'))
# self.connect(self.find_annotations_text_lineEdit, pyqtSignal("return_pressed"), self.return_pressed)
self.find_annotations_text_lineEdit.return_pressed.connect(self.return_pressed)
# self.connect(self.find_annotations_note_lineEdit, pyqtSignal("return_pressed"), self.return_pressed)
self.find_annotations_note_lineEdit.return_pressed.connect(self.return_pressed)
# Date range signals connected in inventory_available()
# ~~~~~~~~ Allow dialog to render before doing inventory ~~~~~~~~
#field = self.prefs.get('cfg_annotations_destination_field', None)
field = get_cc_mapping('annotations', 'field', None)
self.annotated_books_scanner = InventoryAnnotatedBooks(self.opts.gui, field, get_date_range=True)
self.annotated_books_scanner.signal.connect(self.inventory_available)
QTimer.singleShot(1, self.start_inventory_scan)
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle('Preferences')
self.resize(600, 240)
layout = QHBoxLayout()
preview = Preview(self)
#Antonio has a problem with the width of Preview
form = QFormLayout()
self.widthSB = QSpinBox()
self.heightSB = QSpinBox()
self.widthSB.setRange(1, 1000)
self.heightSB.setRange(1, 1000)
self.widthSB.setValue(label_size[0])
self.heightSB.setValue(label_size[1])
form.addRow('Width', self.widthSB)
form.addRow('Height', self.heightSB)
self.spacingDS = DoubleSpin()
self.spacingDS.setX(spacing[0])
self.spacingDS.setY(spacing[1])
form.addRow('Spacing', self.spacingDS)
self.offsetDS = DoubleSpin()
self.offsetDS.setX(first_label_offset[0])
self.offsetDS.setY(first_label_offset[1])
form.addRow('Offset', self.offsetDS)
self.p1 = DoubleSpin()
self.p1.setX(item_positions['article'][0])
self.p1.setY(item_positions['article'][1])
form.addRow('p1', self.p1)
self.p2 = DoubleSpin()
self.p2.setX(item_positions['week'][0])
self.p2.setY(item_positions['week'][1])
form.addRow('p2', self.p2)
self.p3 = DoubleSpin()
self.p3.setX(item_positions['lot'][0])
self.p3.setY(item_positions['lot'][1])
form.addRow('p3', self.p3)
self.p4 = DoubleSpin()
self.p4.setX(item_positions['code'][0])
self.p4.setY(item_positions['code'][1])
form.addRow('p4', self.p4)
self.qr_sizeDS = DoubleSpin()
self.qr_sizeDS.setX(qr_size[0])
self.qr_sizeDS.setY(qr_size[1])
form.addRow('QR size', self.qr_sizeDS)
self.alignament_mark = DoubleSpin()
self.alignament_mark.setX(
item_positions['logo']
[0]) #instead of logo, position of alignment_mark is used
self.alignament_mark.setY(item_positions['logo'][1])
form.addRow('Alignment mark', self.alignament_mark)
self.numberofColumnsSB = QSpinBox()
self.numberofColumnsSB.setRange(1, 10)
self.numberofColumnsSB.setValue(n_columns)
form.addRow('Number of columns', self.numberofColumnsSB)
self.numberofRowsSB = QSpinBox()
self.numberofRowsSB.setRange(1, 50)
self.numberofRowsSB.setValue(n_rows_per_page)
form.addRow('Number of rows', self.numberofRowsSB)
self.fontSizeSB = QSpinBox()
self.fontSizeSB.setRange(4, 25)
self.fontSizeSB.setValue(font['size'])
form.addRow('Font size', self.fontSizeSB)
self.frame_visible = QComboBox()
self.frame_visible.addItem('True')
self.frame_visible.addItem('False')
form.addRow('Frame visible?', self.frame_visible)
pbOk = QPushButton('OK')
pbOk.clicked.connect(self.accept)
form.addRow('', pbOk)
pbCancel = QPushButton('Cancel')
pbCancel.clicked.connect(self.reject)
form.addRow('', pbCancel)
layout.addWidget(preview)
layout.addLayout(form)
self.setLayout(layout)
def __init__(self, parent_dialog, plugin_action):
self.parent_dialog = parent_dialog
self.plugin_action = plugin_action
QWidget.__init__(self)
custom_columns = self.plugin_action.gui.library_view.model().custom_columns
self.l = QVBoxLayout()
self.setLayout(self.l)
label = QLabel(_("Save Source column:"))
label.setToolTip(_("If set, the column below will be populated with the template below to record the source of the split file."))
label.setWordWrap(True)
self.l.addWidget(label)
horz = QHBoxLayout()
self.sourcecol = QComboBox(self)
self.sourcecol.setToolTip(_("Choose a column to populate with template on split."))
self.sourcecol.addItem('','none')
## sort by visible Column Name (vs #name)
for key, column in sorted(custom_columns.items(), key=lambda x: x[1]['name']):
if column['datatype'] in ('text','comments','series'):
self.sourcecol.addItem(column['name'],key)
self.sourcecol.setCurrentIndex(self.sourcecol.findData(prefs['sourcecol']))
horz.addWidget(self.sourcecol)
self.sourcetemplate = QLineEdit(self)
self.sourcetemplate.setToolTip(_("Template from source book. Example: {title} by {authors}"))
# if 'sourcetemplate' in prefs:
self.sourcetemplate.setText(prefs['sourcetemplate'])
# else:
# self.sourcetemplate.setText("{title} by {authors}")
horz.addWidget(self.sourcetemplate)
self.l.addLayout(horz)
self.l.addSpacing(5)
label = QLabel(_("If you have custom columns defined, they will be listed below. Choose if you would like these columns copied to new split books."))
label.setWordWrap(True)
self.l.addWidget(label)
self.l.addSpacing(5)
scrollable = QScrollArea()
scrollcontent = QWidget()
scrollable.setWidget(scrollcontent)
scrollable.setWidgetResizable(True)
self.l.addWidget(scrollable)
self.sl = QVBoxLayout()
scrollcontent.setLayout(self.sl)
self.custcol_checkboxes = {}
## sort by visible Column Name (vs #name)
for key, column in sorted(custom_columns.items(), key=lambda x: x[1]['name']):
# print("\n============== %s ===========\n"%key)
# for (k,v) in six.iteritems(column):
# print("column['%s'] => %s"%(k,v))
checkbox = QCheckBox('%s(%s)'%(column['name'],key))
checkbox.setToolTip(_("Copy this %s column to new split books...")%column['datatype'])
checkbox.setChecked(key in prefs['custom_cols'] and prefs['custom_cols'][key])
self.custcol_checkboxes[key] = checkbox
self.sl.addWidget(checkbox)
self.sl.insertStretch(-1)
def create_filename_box():
self.filename_box = f = QComboBox()
f.setMinimumContentsLength(20), f.setSizeAdjustPolicy(
f.AdjustToMinimumContentsLengthWithIcon)
self.populate_icon_filenames()
def __init__(self, parent):
QWidget.__init__(self, parent)
self.l = l = QGridLayout(self)
l.setContentsMargins(0, 0, 0, 0)
self.setLayout(l)
self.bookmarks_list = bl = BookmarksList(self)
bl.itemChanged.connect(self.item_changed)
l.addWidget(bl, 0, 0, 1, -1)
bl.itemClicked.connect(self.item_activated)
bl.bookmark_activated.connect(self.item_activated)
bl.changed.connect(lambda: self.edited.emit(self.get_bookmarks()))
bl.ac_edit.triggered.connect(self.edit_bookmark)
bl.ac_delete.triggered.connect(self.delete_bookmark)
self.la = la = QLabel(_('Double click to edit the bookmarks'))
la.setWordWrap(True)
l.addWidget(la, l.rowCount(), 0, 1, -1)
self.button_new = b = QPushButton(QIcon(I('bookmarks.png')), _('&New'),
self)
b.clicked.connect(self.create_requested)
b.setToolTip(_('Create a new bookmark at the current location'))
l.addWidget(b)
self.button_delete = b = QPushButton(QIcon(I('trash.png')),
_('&Remove'), self)
b.setToolTip(_('Remove the currently selected bookmark'))
b.clicked.connect(self.delete_bookmark)
l.addWidget(b, l.rowCount() - 1, 1)
self.button_prev = b = QPushButton(QIcon(I('back.png')),
_('Pre&vious'), self)
b.clicked.connect(self.bookmarks_list.previous_bookmark)
l.addWidget(b)
self.button_next = b = QPushButton(QIcon(I('forward.png')), _('Nex&t'),
self)
b.clicked.connect(self.bookmarks_list.next_bookmark)
l.addWidget(b, l.rowCount() - 1, 1)
la = QLabel(_('&Sort by:'))
self.sort_by = sb = QComboBox(self)
la.setBuddy(sb)
sb.addItem(_('Title'), 'title')
sb.addItem(_('Position in book'), 'pos')
sb.addItem(_('Date'), 'timestamp')
sb.setToolTip(_('Change how the bookmarks are sorted'))
i = sb.findData(vprefs['bookmarks_sort'])
if i > -1:
sb.setCurrentIndex(i)
h = QHBoxLayout()
h.addWidget(la), h.addWidget(sb, 10)
l.addLayout(h, l.rowCount(), 0, 1, 2)
sb.currentIndexChanged.connect(self.sort_by_changed)
self.button_export = b = QPushButton(_('E&xport'), self)
b.clicked.connect(self.export_bookmarks)
l.addWidget(b, l.rowCount(), 0)
self.button_import = b = QPushButton(_('&Import'), self)
b.clicked.connect(self.import_bookmarks)
l.addWidget(b, l.rowCount() - 1, 1)
def __init__(self, parent=None, panel_name='search'):
QWidget.__init__(self, parent)
self.ignore_search_type_changes = False
self.l = l = QVBoxLayout(self)
l.setContentsMargins(0, 0, 0, 0)
h = QHBoxLayout()
h.setContentsMargins(0, 0, 0, 0)
l.addLayout(h)
self.search_box = sb = SearchBox(self)
self.panel_name = panel_name
sb.initialize('viewer-{}-panel-expression'.format(panel_name))
sb.item_selected.connect(self.saved_search_selected)
sb.history_saved.connect(self.history_saved)
sb.cleared.connect(self.cleared)
sb.lineEdit().returnPressed.connect(self.find_next)
h.addWidget(sb)
self.next_button = nb = QToolButton(self)
h.addWidget(nb)
nb.setFocusPolicy(Qt.FocusPolicy.NoFocus)
nb.setIcon(QIcon(I('arrow-down.png')))
nb.clicked.connect(self.find_next)
nb.setToolTip(_('Find next match'))
self.prev_button = nb = QToolButton(self)
h.addWidget(nb)
nb.setFocusPolicy(Qt.FocusPolicy.NoFocus)
nb.setIcon(QIcon(I('arrow-up.png')))
nb.clicked.connect(self.find_previous)
nb.setToolTip(_('Find previous match'))
h = QHBoxLayout()
h.setContentsMargins(0, 0, 0, 0)
l.addLayout(h)
self.query_type = qt = QComboBox(self)
qt.setFocusPolicy(Qt.FocusPolicy.NoFocus)
qt.addItem(_('Contains'), 'normal')
qt.addItem(_('Whole words'), 'word')
qt.addItem(_('Regex'), 'regex')
qt.setToolTip(('<p>' + _(
'Choose the type of search: <ul>'
'<li><b>Contains</b> will search for the entered text anywhere.'
'<li><b>Whole words</b> will search for whole words that equal the entered text.'
'<li><b>Regex</b> will interpret the text as a regular expression.'
)))
qt.setCurrentIndex(
qt.findData(
vprefs.get('viewer-{}-mode'.format(self.panel_name), 'normal')
or 'normal'))
qt.currentIndexChanged.connect(self.save_search_type)
h.addWidget(qt)
self.case_sensitive = cs = QCheckBox(_('&Case sensitive'), self)
cs.setFocusPolicy(Qt.FocusPolicy.NoFocus)
cs.setChecked(
bool(
vprefs.get('viewer-{}-case-sensitive'.format(self.panel_name),
False)))
cs.stateChanged.connect(self.save_search_type)
h.addWidget(cs)
self.return_button = rb = QToolButton(self)
rb.setIcon(QIcon(I('back.png')))
rb.setToolTip(_('Go back to where you were before searching'))
rb.clicked.connect(self.go_back)
h.addWidget(rb)
def __init__(self, mi, fmt, opf, oeb, icon):
'''
:param mi: The book metadata
:param fmt: The source format used for conversion
:param opf: The path to the OPF file
:param oeb: An OEB object for the unpacked book
:param icon: The window icon
'''
self.opf = opf
self.oeb = oeb
self.mi = mi
# The unpacked book needs to be parsed before, to read the contents
# of the prince-style file, if it exists
self.parse()
QDialog.__init__(self)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle(_('Convert to PDF with Prince'))
self.setWindowIcon(icon)
self.l = QVBoxLayout()
self.setLayout(self.l)
self.title_label = QLabel(_('<b>Title:</b> %s') % self.mi.title)
self.l.addWidget(self.title_label)
self.format_label = QLabel(_('<b>Source format:</b> %s') % fmt)
self.l.addWidget(self.format_label)
self.add_book = QCheckBox(_('&Add PDF to the book record'))
self.add_book.setToolTip(
_('<qt>Add the converted PDF to the selected book record</qt>'))
self.add_book.setChecked(prefs['add_book'])
self.add_book.stateChanged.connect(self.set_add_book)
self.l.addWidget(self.add_book)
self.ll = QHBoxLayout()
self.ll.setAlignment(Qt.AlignLeft)
self.l.addLayout(self.ll)
self.label_css = QLabel(_('&Custom style:'))
self.ll.addWidget(self.label_css)
self.css_list = QComboBox()
self.css_list.setToolTip(
_('<qt>Select one style to use. Additional styles can be created in the plugin configuration</qt>'
))
for key in sorted(prefs['custom_CSS_list'], key=lambda x: x.lower()):
self.css_list.addItem(key, key)
self.css_list.setCurrentIndex(
self.css_list.findText(prefs['default_CSS']))
self.css_list.currentIndexChanged.connect(self.set_css)
self.ll.addWidget(self.css_list)
self.label_css.setBuddy(self.css_list)
self.ll_ = QHBoxLayout()
self.l.addLayout(self.ll_)
self.label_args = QLabel(_('A&dditional command-line arguments:'))
self.ll_.addWidget(self.label_args)
self.args = QLineEdit(self)
self.args.setText(prefs['custom_args_list'][prefs['default_CSS']])
self.args.setToolTip(
_('<qt>Specify additional command-line arguments for the conversion</qt>'
))
self.ll_.addWidget(self.args)
self.label_args.setBuddy(self.args)
self.css = QTabWidget()
self.l.addWidget(self.css)
self.css1 = TextEditWithTooltip(self, expected_geometry=(80, 20))
self.css1.setLineWrapMode(TextEditWithTooltip.NoWrap)
self.css1.load_text(
self.replace_templates(
prefs['custom_CSS_list'][prefs['default_CSS']]), 'css')
self.css1.setToolTip(
_('<qt>This stylesheet can be modified<br/>The default can be configured</qt>'
))
i = self.css.addTab(self.css1, _('C&ustom CSS'))
self.css.setTabToolTip(
i,
_('<qt>Custom CSS stylesheet to be used for this conversion</qt>'))
monofont = QFont('')
monofont.setStyleHint(QFont.TypeWriter)
if (self.prince_css):
self.css2 = QPlainTextEdit()
self.css2.setStyleSheet('* { font-family: monospace }')
self.css2.setLineWrapMode(QPlainTextEdit.NoWrap)
self.css2.setPlainText(self.prince_css)
self.css2.setReadOnly(True)
self.css2.setToolTip(
_('<qt>This stylesheet cannot be modified</qt>'))
i = self.css.addTab(self.css2, _('&Book CSS'))
self.css.setTabToolTip(
i,
_('<qt>Book-specific CSS stylesheet included in the ebook file</qt>'
))
self.ll = QHBoxLayout()
self.l.addLayout(self.ll)
if (prefs['show_CSS']):
self.toggle = QPushButton(self.hide_text, self)
else:
self.toggle = QPushButton(self.show_text, self)
self.toggle.setToolTip(
_('<qt>Show/hide the additional styles used for the conversion</qt>'
))
self.toggle.clicked.connect(self.toggle_tabs)
self.convert = QPushButton(_('Con&vert'), self)
self.convert.setToolTip(_('<qt>Run the conversion with Prince</qt>'))
self.convert.setDefault(True)
self.buttons = QDialogButtonBox(QDialogButtonBox.Cancel)
self.buttons.addButton(self.toggle, QDialogButtonBox.ResetRole)
self.buttons.addButton(self.convert, QDialogButtonBox.AcceptRole)
self.l.addWidget(self.buttons)
self.buttons.accepted.connect(self.prince_convert)
self.buttons.rejected.connect(self.reject)
if (not prefs['show_CSS']):
self.css.hide()
self.adjustSize()
def __init__(self, plugin_action):
QWidget.__init__(self)
self.parent = plugin_action
self.gui = get_gui()
self.icon = plugin_action.icon
self.opts = plugin_action.opts
self.prefs = plugin_prefs
self.resources_path = plugin_action.resources_path
self.verbose = plugin_action.verbose
self.restart_required = False
self._log_location()
self.l = QGridLayout()
self.setLayout(self.l)
self.column1_layout = QVBoxLayout()
self.l.addLayout(self.column1_layout, 0, 0)
self.column2_layout = QVBoxLayout()
self.l.addLayout(self.column2_layout, 0, 1)
# ----------------------------- Column 1 -----------------------------
# ~~~~~~~~ Create the Custom fields options group box ~~~~~~~~
self.cfg_custom_fields_gb = QGroupBox(self)
self.cfg_custom_fields_gb.setTitle('Custom column assignments')
self.column1_layout.addWidget(self.cfg_custom_fields_gb)
self.cfg_custom_fields_qgl = QGridLayout(self.cfg_custom_fields_gb)
current_row = 0
# ++++++++ Labels + HLine ++++++++
self.marvin_source_label = QLabel("Marvin source")
self.cfg_custom_fields_qgl.addWidget(self.marvin_source_label, current_row, 0)
self.calibre_destination_label = QLabel("calibre destination")
self.cfg_custom_fields_qgl.addWidget(self.calibre_destination_label, current_row, 1)
current_row += 1
self.sd_hl = QFrame(self.cfg_custom_fields_gb)
self.sd_hl.setFrameShape(QFrame.HLine)
self.sd_hl.setFrameShadow(QFrame.Raised)
self.cfg_custom_fields_qgl.addWidget(self.sd_hl, current_row, 0, 1, 3)
current_row += 1
# ++++++++ Annotations ++++++++
self.cfg_annotations_label = QLabel('Annotations')
self.cfg_annotations_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_annotations_label, current_row, 0)
self.annotations_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.annotations_field_comboBox.setObjectName('annotations_field_comboBox')
self.annotations_field_comboBox.setToolTip('Select a custom column to store Marvin annotations')
self.cfg_custom_fields_qgl.addWidget(self.annotations_field_comboBox, current_row, 1)
self.cfg_highlights_wizard = QToolButton()
self.cfg_highlights_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_highlights_wizard.setToolTip("Create a custom column to store Marvin annotations")
self.cfg_highlights_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Annotations'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_highlights_wizard, current_row, 2)
current_row += 1
# ++++++++ Collections ++++++++
self.cfg_collections_label = QLabel('Collections')
self.cfg_collections_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_label, current_row, 0)
self.collection_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.collection_field_comboBox.setObjectName('collection_field_comboBox')
self.collection_field_comboBox.setToolTip('Select a custom column to store Marvin collection assignments')
self.cfg_custom_fields_qgl.addWidget(self.collection_field_comboBox, current_row, 1)
self.cfg_collections_wizard = QToolButton()
self.cfg_collections_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_collections_wizard.setToolTip("Create a custom column for Marvin collection assignments")
self.cfg_collections_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Collections'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_wizard, current_row, 2)
current_row += 1
# ++++++++ Last read ++++++++
self.cfg_date_read_label = QLabel("Last read")
self.cfg_date_read_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_date_read_label, current_row, 0)
self.date_read_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.date_read_field_comboBox.setObjectName('date_read_field_comboBox')
self.date_read_field_comboBox.setToolTip('Select a custom column to store Last read date')
self.cfg_custom_fields_qgl.addWidget(self.date_read_field_comboBox, current_row, 1)
self.cfg_collections_wizard = QToolButton()
self.cfg_collections_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_collections_wizard.setToolTip("Create a custom column to store Last read date")
self.cfg_collections_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Last read'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_wizard, current_row, 2)
current_row += 1
# ++++++++ Locked ++++++++
self.cfg_locked_label = QLabel("Locked")
self.cfg_locked_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_locked_label, current_row, 0)
self.locked_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.locked_field_comboBox.setObjectName('locked_field_comboBox')
self.locked_field_comboBox.setToolTip('Select a custom column to store Locked status')
self.cfg_custom_fields_qgl.addWidget(self.locked_field_comboBox, current_row, 1)
self.cfg_locked_wizard = QToolButton()
self.cfg_locked_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_locked_wizard.setToolTip("Create a custom column to store Locked status")
self.cfg_locked_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Locked'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_locked_wizard, current_row, 2)
current_row += 1
# ++++++++ Progress ++++++++
self.cfg_progress_label = QLabel('Progress')
self.cfg_progress_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_progress_label, current_row, 0)
self.progress_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.progress_field_comboBox.setObjectName('progress_field_comboBox')
self.progress_field_comboBox.setToolTip('Select a custom column to store Marvin reading progress')
self.cfg_custom_fields_qgl.addWidget(self.progress_field_comboBox, current_row, 1)
self.cfg_progress_wizard = QToolButton()
self.cfg_progress_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_progress_wizard.setToolTip("Create a custom column to store Marvin reading progress")
self.cfg_progress_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Progress'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_progress_wizard, current_row, 2)
current_row += 1
# ++++++++ Read flag ++++++++
self.cfg_read_label = QLabel('Read')
self.cfg_read_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_read_label, current_row, 0)
self.read_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.read_field_comboBox.setObjectName('read_field_comboBox')
self.read_field_comboBox.setToolTip('Select a custom column to store Marvin Read status')
self.cfg_custom_fields_qgl.addWidget(self.read_field_comboBox, current_row, 1)
self.cfg_read_wizard = QToolButton()
self.cfg_read_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_read_wizard.setToolTip("Create a custom column to store Marvin Read status")
self.cfg_read_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Read'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_read_wizard, current_row, 2)
current_row += 1
# ++++++++ Reading list flag ++++++++
self.cfg_reading_list_label = QLabel('Reading list')
self.cfg_reading_list_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_reading_list_label, current_row, 0)
self.reading_list_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.reading_list_field_comboBox.setObjectName('reading_list_field_comboBox')
self.reading_list_field_comboBox.setToolTip('Select a custom column to store Marvin Reading list status')
self.cfg_custom_fields_qgl.addWidget(self.reading_list_field_comboBox, current_row, 1)
self.cfg_reading_list_wizard = QToolButton()
self.cfg_reading_list_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_reading_list_wizard.setToolTip("Create a custom column to store Marvin Reading list status")
self.cfg_reading_list_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Reading list'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_reading_list_wizard, current_row, 2)
current_row += 1
# ++++++++ Word count ++++++++
self.cfg_word_count_label = QLabel('Word count')
self.cfg_word_count_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_word_count_label, current_row, 0)
self.word_count_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.word_count_field_comboBox.setObjectName('word_count_field_comboBox')
self.word_count_field_comboBox.setToolTip('Select a custom column to store Marvin word counts')
self.cfg_custom_fields_qgl.addWidget(self.word_count_field_comboBox, current_row, 1)
self.cfg_word_count_wizard = QToolButton()
self.cfg_word_count_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_word_count_wizard.setToolTip("Create a custom column to store Marvin word counts")
self.cfg_word_count_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Word count'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_word_count_wizard, current_row, 2)
current_row += 1
self.spacerItem1 = QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.column1_layout.addItem(self.spacerItem1)
# ----------------------------- Column 2 -----------------------------
# ~~~~~~~~ Create the CSS group box ~~~~~~~~
self.cfg_css_options_gb = QGroupBox(self)
self.cfg_css_options_gb.setTitle('CSS')
self.column2_layout.addWidget(self.cfg_css_options_gb)
self.cfg_css_options_qgl = QGridLayout(self.cfg_css_options_gb)
current_row = 0
# ++++++++ Annotations appearance ++++++++
self.annotations_icon = QIcon(os.path.join(self.resources_path, 'icons', 'annotations_hiliter.png'))
self.cfg_annotations_appearance_toolbutton = QToolButton()
self.cfg_annotations_appearance_toolbutton.setIcon(self.annotations_icon)
self.cfg_annotations_appearance_toolbutton.clicked.connect(self.configure_appearance)
self.cfg_css_options_qgl.addWidget(self.cfg_annotations_appearance_toolbutton, current_row, 0)
self.cfg_annotations_label = ClickableQLabel("Book notes, Bookmark notes and Annotations")
self.cfg_annotations_label.clicked.connect(self.configure_appearance)
self.cfg_css_options_qgl.addWidget(self.cfg_annotations_label, current_row, 1)
current_row += 1
# ++++++++ Injected CSS ++++++++
self.css_editor_icon = QIcon(I('format-text-heading.png'))
self.cfg_css_editor_toolbutton = QToolButton()
self.cfg_css_editor_toolbutton.setIcon(self.css_editor_icon)
self.cfg_css_editor_toolbutton.clicked.connect(self.edit_css)
self.cfg_css_options_qgl.addWidget(self.cfg_css_editor_toolbutton, current_row, 0)
self.cfg_css_editor_label = ClickableQLabel("Articles, Vocabulary")
self.cfg_css_editor_label.clicked.connect(self.edit_css)
self.cfg_css_options_qgl.addWidget(self.cfg_css_editor_label, current_row, 1)
"""
# ~~~~~~~~ Create the Dropbox syncing group box ~~~~~~~~
self.cfg_dropbox_syncing_gb = QGroupBox(self)
self.cfg_dropbox_syncing_gb.setTitle('Dropbox')
self.column2_layout.addWidget(self.cfg_dropbox_syncing_gb)
self.cfg_dropbox_syncing_qgl = QGridLayout(self.cfg_dropbox_syncing_gb)
current_row = 0
# ++++++++ Syncing enabled checkbox ++++++++
self.dropbox_syncing_checkbox = QCheckBox('Enable Dropbox updates')
self.dropbox_syncing_checkbox.setObjectName('dropbox_syncing')
self.dropbox_syncing_checkbox.setToolTip('Refresh custom column content from Marvin metadata')
self.cfg_dropbox_syncing_qgl.addWidget(self.dropbox_syncing_checkbox,
current_row, 0, 1, 3)
current_row += 1
# ++++++++ Dropbox folder picker ++++++++
self.dropbox_folder_icon = QIcon(os.path.join(self.resources_path, 'icons', 'dropbox.png'))
self.cfg_dropbox_folder_toolbutton = QToolButton()
self.cfg_dropbox_folder_toolbutton.setIcon(self.dropbox_folder_icon)
self.cfg_dropbox_folder_toolbutton.setToolTip("Specify Dropbox folder location on your computer")
self.cfg_dropbox_folder_toolbutton.clicked.connect(self.select_dropbox_folder)
self.cfg_dropbox_syncing_qgl.addWidget(self.cfg_dropbox_folder_toolbutton,
current_row, 1)
# ++++++++ Dropbox location lineedit ++++++++
self.dropbox_location_lineedit = QLineEdit()
self.dropbox_location_lineedit.setPlaceholderText("Dropbox folder location")
self.cfg_dropbox_syncing_qgl.addWidget(self.dropbox_location_lineedit,
current_row, 2)
"""
# ~~~~~~~~ Create the General options group box ~~~~~~~~
self.cfg_runtime_options_gb = QGroupBox(self)
self.cfg_runtime_options_gb.setTitle('General options')
self.column2_layout.addWidget(self.cfg_runtime_options_gb)
self.cfg_runtime_options_qvl = QVBoxLayout(self.cfg_runtime_options_gb)
# ++++++++ Temporary markers: Duplicates ++++++++
self.duplicate_markers_checkbox = QCheckBox('Apply temporary markers to duplicate books')
self.duplicate_markers_checkbox.setObjectName('apply_markers_to_duplicates')
self.duplicate_markers_checkbox.setToolTip('Books with identical content will be flagged in the Library window')
self.cfg_runtime_options_qvl.addWidget(self.duplicate_markers_checkbox)
# ++++++++ Temporary markers: Updated ++++++++
self.updated_markers_checkbox = QCheckBox('Apply temporary markers to books with updated content')
self.updated_markers_checkbox.setObjectName('apply_markers_to_updated')
self.updated_markers_checkbox.setToolTip('Books with updated content will be flagged in the Library window')
self.cfg_runtime_options_qvl.addWidget(self.updated_markers_checkbox)
# ++++++++ Auto refresh checkbox ++++++++
self.auto_refresh_checkbox = QCheckBox('Automatically refresh custom column content')
self.auto_refresh_checkbox.setObjectName('auto_refresh_at_startup')
self.auto_refresh_checkbox.setToolTip('Update calibre custom column when Marvin XD is opened')
self.cfg_runtime_options_qvl.addWidget(self.auto_refresh_checkbox)
# ++++++++ Progress as percentage checkbox ++++++++
self.reading_progress_checkbox = QCheckBox('Show reading progress as percentage')
self.reading_progress_checkbox.setObjectName('show_progress_as_percentage')
self.reading_progress_checkbox.setToolTip('Display percentage in Progress column')
self.cfg_runtime_options_qvl.addWidget(self.reading_progress_checkbox)
# ~~~~~~~~ Create the Debug options group box ~~~~~~~~
self.cfg_debug_options_gb = QGroupBox(self)
self.cfg_debug_options_gb.setTitle('Debug options')
self.column2_layout.addWidget(self.cfg_debug_options_gb)
self.cfg_debug_options_qvl = QVBoxLayout(self.cfg_debug_options_gb)
# ++++++++ Debug logging checkboxes ++++++++
self.debug_plugin_checkbox = QCheckBox('Enable debug logging for Marvin XD')
self.debug_plugin_checkbox.setObjectName('debug_plugin_checkbox')
self.debug_plugin_checkbox.setToolTip('Print plugin diagnostic messages to console')
self.cfg_debug_options_qvl.addWidget(self.debug_plugin_checkbox)
self.debug_libimobiledevice_checkbox = QCheckBox('Enable debug logging for libiMobileDevice')
self.debug_libimobiledevice_checkbox.setObjectName('debug_libimobiledevice_checkbox')
self.debug_libimobiledevice_checkbox.setToolTip('Print libiMobileDevice diagnostic messages to console')
self.cfg_debug_options_qvl.addWidget(self.debug_libimobiledevice_checkbox)
self.spacerItem2 = QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.column2_layout.addItem(self.spacerItem2)
# ~~~~~~~~ End of construction zone ~~~~~~~~
self.resize(self.sizeHint())
# ~~~~~~~~ Populate/restore config options ~~~~~~~~
# Annotations comboBox
self.populate_annotations()
self.populate_collections()
self.populate_date_read()
self.populate_locked()
self.populate_progress()
self.populate_read()
self.populate_reading_list()
self.populate_word_count()
"""
# Restore Dropbox settings, hook changes
dropbox_syncing = self.prefs.get('dropbox_syncing', False)
self.dropbox_syncing_checkbox.setChecked(dropbox_syncing)
self.set_dropbox_syncing(dropbox_syncing)
self.dropbox_syncing_checkbox.clicked.connect(partial(self.set_dropbox_syncing))
self.dropbox_location_lineedit.setText(self.prefs.get('dropbox_folder', ''))
"""
# Restore general settings
self.duplicate_markers_checkbox.setChecked(self.prefs.get('apply_markers_to_duplicates', True))
self.updated_markers_checkbox.setChecked(self.prefs.get('apply_markers_to_updated', True))
self.auto_refresh_checkbox.setChecked(self.prefs.get('auto_refresh_at_startup', False))
self.reading_progress_checkbox.setChecked(self.prefs.get('show_progress_as_percentage', False))
# Restore debug settings, hook changes
self.debug_plugin_checkbox.setChecked(self.prefs.get('debug_plugin', False))
self.debug_plugin_checkbox.stateChanged.connect(self.set_restart_required)
self.debug_libimobiledevice_checkbox.setChecked(self.prefs.get('debug_libimobiledevice', False))
self.debug_libimobiledevice_checkbox.stateChanged.connect(self.set_restart_required)
# Hook changes to Annotations comboBox
# self.annotations_field_comboBox.currentIndexChanged.connect(
# partial(self.save_combobox_setting, 'annotations_field_comboBox'))
# self.connect(self.annotations_field_comboBox,
# SIGNAL('currentIndexChanged(const QString &)'),
# self.annotations_destination_changed)
self.annotations_field_comboBox.currentIndexChanged.connect(self.annotations_destination_changed)
# Launch the annotated_books_scanner
field = get_cc_mapping('annotations', 'field', None)
self.annotated_books_scanner = InventoryAnnotatedBooks(self.gui, field)
self.annotated_books_scanner.signal.connect(self.inventory_complete)
QTimer.singleShot(1, self.start_inventory)
def __init__(self, plugin_action):
QWidget.__init__(self)
self.plugin_action = plugin_action
layout = QVBoxLayout(self)
self.setLayout(layout)
# --- Directory Options ---
directory_group_box = QGroupBox(_('Default Unpack Directory:'), self)
layout.addWidget(directory_group_box)
directory_group_box_layout = QVBoxLayout()
directory_group_box.setLayout(directory_group_box_layout)
# Directory path Textbox
# Load the textbox with the current preference setting
self.directory_txtBox = QLineEdit(plugin_prefs['Unpack_Folder'], self)
self.directory_txtBox.setToolTip(
_('<p>Default directory to extract files to'))
directory_group_box_layout.addWidget(self.directory_txtBox)
self.directory_txtBox.setReadOnly(True)
# Folder select button
directory_button = QPushButton(_('Select/Change Unpack Directory'),
self)
directory_button.setToolTip(
_('<p>Select/Change directory to extract files to.'))
# Connect button to the getDirectory function
directory_button.clicked.connect(self.getDirectory)
directory_group_box_layout.addWidget(directory_button)
self.default_folder_check = QCheckBox(
_('Always use the Default Unpack Directory'), self)
self.default_folder_check.setToolTip(
_('<p>When unchecked... you will be prompted to select a destination '
+
'directory for the extracted content each time you use Mobiunpack.'
))
directory_group_box_layout.addWidget(self.default_folder_check)
# Load the checkbox with the current preference setting
self.default_folder_check.setChecked(
plugin_prefs['Always_Use_Unpack_Folder'])
misc_group_box = QGroupBox(_('Default settings:'), self)
layout.addWidget(misc_group_box)
misc_group_box_layout = QVBoxLayout()
misc_group_box.setLayout(misc_group_box_layout)
self.use_hd_images = QCheckBox(_('Always use HD images if present'),
self)
self.use_hd_images.setToolTip(
_('<p>When checked... any HD images present in the kindlebook ' +
'will be used for creating the ePub.'))
misc_group_box_layout.addWidget(self.use_hd_images)
# Load the checkbox with the current preference setting
self.use_hd_images.setChecked(plugin_prefs['Use_HD_Images'])
combo_label = QLabel(_('Select epub version output:'), self)
misc_group_box_layout.addWidget(combo_label)
self.epub_version_combobox = QComboBox()
self.epub_version_combobox.setToolTip(
_('<p>Select the type of OPF file to create.'))
misc_group_box_layout.addWidget(self.epub_version_combobox)
self.epub_version_combobox.addItems(
[_('Auto-detect'), _('ePub2'),
_('ePub3')])
if plugin_prefs['Epub_Version'] == 'A':
self.epub_version_combobox.setCurrentIndex(0)
else:
self.epub_version_combobox.setCurrentIndex(
int(plugin_prefs['Epub_Version']) - 1)
# --- ZIP mod Options ---
zip_mod_group_box = QGroupBox(_('ZIP mod settings:'), self)
layout.addWidget(zip_mod_group_box)
zip_mod_group_box_layout = QVBoxLayout()
zip_mod_group_box.setLayout(zip_mod_group_box_layout)
zip_mod_combo_label = QLabel(_('Select zip compress type:'), self)
zip_mod_group_box_layout.addWidget(zip_mod_combo_label)
self.zip_compress_type_combobox = QComboBox()
self.zip_compress_type_combobox.setToolTip(
_('<p>Select the type of zip compress.'))
zip_mod_group_box_layout.addWidget(self.zip_compress_type_combobox)
self.zip_compress_type_combobox.addItems([_('STORE'), _('DEFLATE')])
if plugin_prefs['Zip_Compress_Type'] == 'S':
self.zip_compress_type_combobox.setCurrentIndex(0)
else:
self.zip_compress_type_combobox.setCurrentIndex(1)
# Directory path Textbox
# Load the textbox with the current preference setting
kindle_directory_label = QLabel(_('Kindle Content Directory:'), self)
zip_mod_group_box_layout.addWidget(kindle_directory_label)
self.kindle_directory_txtBox = QLineEdit(
plugin_prefs['Kindle_Content_Folder'], self)
self.kindle_directory_txtBox.setToolTip(
_('<p>Kindle Content directory.'))
zip_mod_group_box_layout.addWidget(self.kindle_directory_txtBox)
self.kindle_directory_txtBox.setReadOnly(True)
# Folder select button
kindle_directory_button = QPushButton(
_('Select/Change Kindle Content Directory'), self)
kindle_directory_button.setToolTip(
_('<p>Select/Change Kindle Content directory.'))
# Connect button to the getDirectory function
kindle_directory_button.clicked.connect(self.getDirectoryKindleContent)
zip_mod_group_box_layout.addWidget(kindle_directory_button)
self.delete_temp_files = QCheckBox(_('Always delete temporary files'),
self)
self.delete_temp_files.setToolTip(
_('<p>When checked... Delete temporary files at end of unpack.'))
zip_mod_group_box_layout.addWidget(self.delete_temp_files)
# Load the checkbox with the current preference setting
self.delete_temp_files.setChecked(
plugin_prefs['Always_Delete_Temp_Files'])
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
from PyQt5.Qt import QApplication, QWidget, QVBoxLayout, QComboBox
app = QApplication([])
combo_box = QComboBox()
for i in range(10):
combo_box.addItem("item_" + str(i + 1))
# QStandardItemModel, метод model.item возвращает объекты QStandardItem
model = combo_box.model()
# Указываем какие элементы сделать невыбираемыми
model.item(0).setEnabled(False)
model.item(2).setEnabled(False)
model.item(4).setEnabled(False)
combo_box.setCurrentIndex(-1)
layout = QVBoxLayout()
layout.addWidget(combo_box)
mw = QWidget()
mw.setLayout(layout)
mw.show()
def __init__(self):
"""Constructor"""
QMainWindow.__init__(self)
global_properties = GlobalProperties.get_instance()
self.connection_table = ConnectionTableWidget()
global_properties.add_listener(self.connection_table)
self.setCentralWidget(self.connection_table)
self.connection_table.update()
self.menu_bar = self.menuBar()
self.menu_file = self.menu_bar.addMenu('File')
self.menu_file.addAction('New', file_new_clicked)
self.menu_file.addAction('Open', self.file_load)
self.menu_file.addSeparator()
self.menu_file.addAction('Save', self.file_save)
self.menu_file.addAction('Save as', self.file_save_as)
self.menu_file.addSeparator()
self.menu_file.addAction('Exit', sys.exit)
self.menu_file = self.menu_bar.addMenu('Connections')
self.make_birectional_menu = self.menu_file.addMenu(
'Make bidirectional')
self.make_birectional_menu.addAction("with and",
make_bidirectional_and)
self.make_birectional_menu.addAction("with or", make_bidirectional_or)
self.menu_selection = self.menu_bar.addMenu('Selections')
self.action_add_selection = self.menu_selection.addAction(
'Add Selection')
self.action_add_selection.triggered.connect(
create_add_selection_window)
self.action_merge_selections = self.menu_selection.addAction(
'Merge Selections')
self.action_merge_selections.triggered.connect(
create_merge_selectoon_window)
self.setMenuBar(self.menu_bar)
self.statusBar().showMessage('Welcome to mpdj!', 5000)
self.mpdj_options_dock = QDockWidget("MPDJ Options Panel", self)
self.mpdj_options_dock_layout = QFormLayout()
self.mpdj_docked_widget = QWidget()
self.tf_min_global_song_duration = QLineEdit()
self.tf_min_global_song_duration.setValidator(
QIntValidator(0, 2147483647))
self.mpdj_options_dock_layout.addRow('Global min song duration:',
self.tf_min_global_song_duration)
self.tf_min_global_song_duration.editingFinished.connect(
self.write_min_global_song_duration_to_mpdj)
self.tf_max_global_song_duration = QLineEdit()
self.tf_max_global_song_duration.setValidator(
QIntValidator(0, 2147483647))
self.mpdj_options_dock_layout.addRow('Global max song duration:',
self.tf_max_global_song_duration)
self.tf_max_global_song_duration.editingFinished.connect(
self.write_max_global_song_duration_to_mpdj)
self.tf_min_per_selection = QLineEdit()
self.tf_min_per_selection.setValidator(QIntValidator(0, 2147483647))
self.mpdj_options_dock_layout.addRow('Min per Node touch:',
self.tf_min_per_selection)
self.tf_min_per_selection.editingFinished.connect(
self.write_min_per_note_to_mpdj)
self.tf_max_per_selection = QLineEdit()
self.tf_max_per_selection.setValidator(QIntValidator(0, 2147483647))
self.mpdj_options_dock_layout.addRow('Max per Node touch:',
self.tf_max_per_selection)
self.tf_max_per_selection.editingFinished.connect(
self.write_max_per_note_to_mpdj)
self.combo_box_minutes_or_titles = QComboBox()
self.combo_box_minutes_or_titles.addItems(
[unit.gui_representation() for unit in UnitPerNodeTouch])
self.mpdj_options_dock_layout.addRow('Unit:',
self.combo_box_minutes_or_titles)
self.combo_box_minutes_or_titles.currentTextChanged.connect(
self.write_unit_per_node_touch_to_mpdj)
self.tf_global_node_max_overflow_minutes = QLineEdit()
self.tf_global_node_max_overflow_minutes.setValidator(
QIntValidator(0, 2147483647))
self.tf_global_node_max_overflow_minutes.editingFinished.connect(
self.write_global_node_max_overflow_to_mpdj)
self.cb_global_limit_overflow = QCheckBox()
self.cb_global_limit_overflow.stateChanged.connect(lambda: list(
map(lambda m: m(), [
lambda: self.tf_global_node_max_overflow_minutes.setDisabled(
not self.cb_global_limit_overflow.isChecked()), self.
write_limit_overspill_to_mpdj
])))
self.overflow_layoout = QHBoxLayout()
self.overflow_layoout.addWidget(self.cb_global_limit_overflow)
self.overflow_layoout.addWidget(
self.tf_global_node_max_overflow_minutes)
self.mpdj_options_dock_layout.addRow("Limit overflow:",
self.overflow_layoout)
self.mpdj_docked_widget.setLayout(self.mpdj_options_dock_layout)
self.mpdj_options_dock.setWidget(self.mpdj_docked_widget)
self.addDockWidget(Qt.LeftDockWidgetArea, self.mpdj_options_dock)
self.chk_box_graph_is_directed = QCheckBox()
self.chk_box_graph_is_directed.stateChanged.connect(
self.write_graph_is_directed_to_mpdj)
self.mpdj_options_dock_layout.addRow(QLabel('Graph is directed'),
self.chk_box_graph_is_directed)
self.opened_selection_window = None
global_properties.add_listener(self)
self.update()
def __init__(self,
parent,
db,
author,
series=None,
title=None,
dup_title=None):
QDialog.__init__(self, parent)
self.db = db
self.setWindowTitle(_('How many empty books?'))
self._layout = QGridLayout(self)
self.setLayout(self._layout)
self.qty_label = QLabel(_('How many empty books should be added?'))
self._layout.addWidget(self.qty_label, 0, 0, 1, 2)
self.qty_spinbox = QSpinBox(self)
self.qty_spinbox.setRange(1, 10000)
self.qty_spinbox.setValue(1)
self._layout.addWidget(self.qty_spinbox, 1, 0, 1, 2)
self.author_label = QLabel(_('Set the author of the new books to:'))
self._layout.addWidget(self.author_label, 2, 0, 1, 2)
self.authors_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.authors_combo.setEditable(True)
self._layout.addWidget(self.authors_combo, 3, 0, 1, 1)
self.initialize_authors(db, author)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon(I('trash.png')))
self.clear_button.setToolTip(_('Reset author to Unknown'))
self.clear_button.clicked.connect(self.reset_author)
self._layout.addWidget(self.clear_button, 3, 1, 1, 1)
self.series_label = QLabel(_('Set the series of the new books to:'))
self._layout.addWidget(self.series_label, 4, 0, 1, 2)
self.series_combo = EditWithComplete(self)
self.series_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.series_combo.setEditable(True)
self._layout.addWidget(self.series_combo, 5, 0, 1, 1)
self.initialize_series(db, series)
self.sclear_button = QToolButton(self)
self.sclear_button.setIcon(QIcon(I('trash.png')))
self.sclear_button.setToolTip(_('Reset series'))
self.sclear_button.clicked.connect(self.reset_series)
self._layout.addWidget(self.sclear_button, 5, 1, 1, 1)
self.title_label = QLabel(_('Set the title of the new books to:'))
self._layout.addWidget(self.title_label, 6, 0, 1, 2)
self.title_edit = QLineEdit(self)
self.title_edit.setText(title or '')
self._layout.addWidget(self.title_edit, 7, 0, 1, 1)
self.tclear_button = QToolButton(self)
self.tclear_button.setIcon(QIcon(I('trash.png')))
self.tclear_button.setToolTip(_('Reset title'))
self.tclear_button.clicked.connect(self.title_edit.clear)
self._layout.addWidget(self.tclear_button, 7, 1, 1, 1)
self.format_label = QLabel(_('Also create an empty e-book in format:'))
self._layout.addWidget(self.format_label, 8, 0, 1, 2)
c = self.format_value = QComboBox(self)
from calibre.ebooks.oeb.polish.create import valid_empty_formats
possible_formats = [''] + sorted(x.upper()
for x in valid_empty_formats)
c.addItems(possible_formats)
c.setToolTip(
_('Also create an empty book format file that you can subsequently edit'
))
if gprefs.get('create_empty_epub_file', False):
# Migration of the check box
gprefs.set('create_empty_format_file', 'epub')
del gprefs['create_empty_epub_file']
use_format = gprefs.get('create_empty_format_file', '').upper()
try:
c.setCurrentIndex(possible_formats.index(use_format))
except Exception:
pass
self._layout.addWidget(c, 9, 0, 1, 1)
self.copy_formats = cf = QCheckBox(
_('Also copy book &formats when duplicating a book'), self)
cf.setToolTip(
_('Also copy all e-book files into the newly created duplicate'
' books.'))
cf.setChecked(gprefs.get('create_empty_copy_dup_formats', False))
self._layout.addWidget(cf, 10, 0, 1, -1)
button_box = self.bb = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self._layout.addWidget(button_box, 11, 0, 1, -1)
if dup_title:
self.dup_button = b = button_box.addButton(
_('&Duplicate current book'), button_box.ActionRole)
b.clicked.connect(self.do_duplicate_book)
b.setIcon(QIcon(I('edit-copy.png')))
b.setToolTip(
_('Make the new empty book records exact duplicates\n'
'of the current book "%s", with all metadata identical') %
dup_title)
self.resize(self.sizeHint())
self.duplicate_current_book = False
def __init__(self, appinst, profilecon, settingscon, *args, **kwargs):
super().__init__(*args, **kwargs)
self.app = appinst
self.profilecon = profilecon # connector class instance for reading/writing profile settings
self.settingscon = settingscon
self.gcode = None
self.machine = None
self.backgroundTask = None
self.postBackgroundTask = None
self.coord_plot_items = list(
) # list of all plot items added to the coord plot
self.mainlayout = QVBoxLayout(self)
self.mainlayout.setContentsMargins(0, 0, 0, 0)
self.toolBar = QToolBar()
self.toolBar.setStyleSheet("""QToolBar {background-color: white;
border-top: 1px solid black}"""
)
self.mainlayout.addWidget(self.toolBar)
self.add_toolbar_action("./res/folder.svg", "Open",
self.open_file_dialog)
self.add_toolbar_action("./res/x-square.svg", "Close", self.close_file)
self.add_toolbar_action("./res/save.svg", "Export", self.export)
self.toolBar.addSeparator()
self.add_toolbar_action("./res/sliders.svg", "Settings",
self.open_settings_dialog)
self.add_toolbar_action("./res/play.svg", "Simulate",
self.start_simulation)
self.toolBar.addSeparator()
self.add_toolbar_action("./res/maximize.svg", "Fit to View",
self.fit_plot_to_window)
self.add_toolbar_action("./res/maximize-2.svg", "Reset View",
self.reset_plot_view)
self.toolBar.addSeparator()
self.profileSelector = QComboBox()
for name in self.profilecon.list_profiles():
self.profileSelector.addItem(name)
self.profileSelector.setCurrentText(
self.settingscon.get_value("Current_Profile"))
self.profilecon.select_profile(
self.settingscon.get_value("Current_Profile"))
self.toolBar.addWidget(self.profileSelector)
self.profileSelector.currentTextChanged.connect(
self.selected_profile_changed)
divider = QWidget()
divider.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolBar.addWidget(divider)
self.add_toolbar_action("./res/info.svg", "About",
self.open_about_dialog)
self.contentLayout = QHBoxLayout()
self.contentLayout.setContentsMargins(10, 10, 10, 10)
self.mainlayout.addLayout(self.contentLayout)
self.layerSlider = QSlider()
self.layerSlider.setMinimum(0)
self.layerSlider.setValue(0)
self.layerSlider.setDisabled(True)
self.layerSlider.valueChanged.connect(self.show_layer)
self.contentLayout.addWidget(self.layerSlider)
self.coordPlot = PlotWidget()
self.coordPlot.setAspectLocked(True)
# self.coordPlot.setLimits(xMin=0, yMin=0)
self.configure_plot(
) # is done in a seperate funciton because values need to be updated after settings are changed
self.contentLayout.addWidget(self.coordPlot)
self.sidebarlayout = QVBoxLayout()
self.contentLayout.addLayout(self.sidebarlayout)
self.sidebarheader = QLabel("Options")
self.sidebarheader.setFixedSize(300, 50)
self.sidebarlayout.addWidget(self.sidebarheader)
def initialize(self):
ConfigWidgetBase.initialize(self)
self.current_plugboards = copy.deepcopy(self.db.prefs.get('plugboards',{}))
self.current_device = None
self.current_format = None
if self.gui.device_manager.connected_device is not None:
self.device_label.setText(_('Device currently connected: ') +
self.gui.device_manager.connected_device.__class__.__name__)
else:
self.device_label.setText(_('Device currently connected: None'))
self.devices = ['', 'APPLE', 'FOLDER_DEVICE']
self.disabled_devices = []
self.device_to_formats_map = {}
for device in device_plugins():
n = device_name_for_plugboards(device)
self.device_to_formats_map[n] = set(device.settings().format_map)
if getattr(device, 'CAN_DO_DEVICE_DB_PLUGBOARD', False):
self.device_to_formats_map[n].add('device_db')
if n not in self.devices:
self.devices.append(n)
for device in disabled_device_plugins():
n = device_name_for_plugboards(device)
if n not in self.disabled_devices:
self.disabled_devices.append(n)
self.devices.sort(key=lambda x: x.lower())
self.devices.insert(1, plugboard_save_to_disk_value)
self.devices.insert(1, plugboard_content_server_value)
self.device_to_formats_map[plugboard_content_server_value] = \
plugboard_content_server_formats
self.devices.insert(1, plugboard_email_value)
self.device_to_formats_map[plugboard_email_value] = \
plugboard_email_formats
self.devices.insert(1, plugboard_any_device_value)
self.new_device.addItems(self.devices)
self.formats = ['']
self.format_to_writers_map = defaultdict(list)
for w in metadata_writers():
for f in w.file_types:
if f not in self.formats:
self.formats.append(f)
self.format_to_writers_map[f].append(w)
self.formats.append('device_db')
self.formats.sort()
self.formats.insert(1, plugboard_any_format_value)
self.new_format.addItems(self.formats)
self.dest_fields = ['',
'authors', 'author_sort', 'language', 'publisher',
'series', 'tags', 'title', 'title_sort', 'comments']
self.source_widgets = []
self.dest_widgets = []
for i in range(0, len(self.dest_fields)-1):
w = TemplateLineEditor(self)
self.source_widgets.append(w)
self.fields_layout.addWidget(w, 5+i, 0, 1, 1)
w = QComboBox(self)
self.dest_widgets.append(w)
self.fields_layout.addWidget(w, 5+i, 1, 1, 1)
self.edit_device.currentIndexChanged[native_string_type].connect(self.edit_device_changed)
self.edit_format.currentIndexChanged[native_string_type].connect(self.edit_format_changed)
self.new_device.currentIndexChanged[native_string_type].connect(self.new_device_changed)
self.new_format.currentIndexChanged[native_string_type].connect(self.new_format_changed)
self.existing_plugboards.itemClicked.connect(self.existing_pb_clicked)
self.ok_button.clicked.connect(self.ok_clicked)
self.del_button.clicked.connect(self.del_clicked)
self.refilling = False
self.refill_all_boxes()
def __init__(self, gui, icon, do_user_config):
QDialog.__init__(self, gui)
self.gui = gui
self.do_user_config = do_user_config
self.db = gui.current_db.new_api
# The model for the book list
self.model = OpdsBooksModel(None, self.dummy_books(), self.db)
self.searchproxymodel = QSortFilterProxyModel(self)
self.searchproxymodel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.searchproxymodel.setFilterKeyColumn(-1)
self.searchproxymodel.setSourceModel(self.model)
self.layout = QGridLayout()
self.setLayout(self.layout)
self.setWindowTitle('OPDS Client')
self.setWindowIcon(icon)
labelColumnWidths = []
self.opdsUrlLabel = QLabel('OPDS URL: ')
self.layout.addWidget(self.opdsUrlLabel, 0, 0)
labelColumnWidths.append(
self.layout.itemAtPosition(0, 0).sizeHint().width())
config.convertSingleStringOpdsUrlPreferenceToListOfStringsPreference()
self.opdsUrlEditor = QComboBox(self)
self.opdsUrlEditor.activated.connect(self.opdsUrlEditorActivated)
self.opdsUrlEditor.addItems(prefs['opds_url'])
self.opdsUrlEditor.setEditable(True)
self.opdsUrlEditor.setInsertPolicy(QComboBox.InsertAtTop)
self.layout.addWidget(self.opdsUrlEditor, 0, 1, 1, 3)
self.opdsUrlLabel.setBuddy(self.opdsUrlEditor)
buttonColumnNumber = 7
buttonColumnWidths = []
self.about_button = QPushButton('About', self)
self.about_button.setAutoDefault(False)
self.about_button.clicked.connect(self.about)
self.layout.addWidget(self.about_button, 0, buttonColumnNumber)
buttonColumnWidths.append(
self.layout.itemAtPosition(0,
buttonColumnNumber).sizeHint().width())
# Initially download the catalogs found in the root catalog of the URL
# selected at startup. Fail quietly on failing to open the URL
catalogsTuple = self.model.downloadOpdsRootCatalog(
self.gui, self.opdsUrlEditor.currentText(), False)
print catalogsTuple
firstCatalogTitle = catalogsTuple[0]
self.currentOpdsCatalogs = catalogsTuple[
1] # A dictionary of title->feedURL
self.opdsCatalogSelectorLabel = QLabel('OPDS Catalog:')
self.layout.addWidget(self.opdsCatalogSelectorLabel, 1, 0)
labelColumnWidths.append(
self.layout.itemAtPosition(1, 0).sizeHint().width())
self.opdsCatalogSelector = QComboBox(self)
self.opdsCatalogSelector.setEditable(False)
self.opdsCatalogSelectorModel = QStringListModel(
self.currentOpdsCatalogs.keys())
self.opdsCatalogSelector.setModel(self.opdsCatalogSelectorModel)
self.opdsCatalogSelector.setCurrentText(firstCatalogTitle)
self.layout.addWidget(self.opdsCatalogSelector, 1, 1, 1, 3)
self.download_opds_button = QPushButton('Download OPDS', self)
self.download_opds_button.setAutoDefault(False)
self.download_opds_button.clicked.connect(self.download_opds)
self.layout.addWidget(self.download_opds_button, 1, buttonColumnNumber)
buttonColumnWidths.append(
self.layout.itemAtPosition(1,
buttonColumnNumber).sizeHint().width())
# Search GUI
self.searchEditor = QLineEdit(self)
self.searchEditor.returnPressed.connect(self.searchBookList)
self.layout.addWidget(self.searchEditor, 2, buttonColumnNumber - 2, 1,
2)
self.searchButton = QPushButton('Search', self)
self.searchButton.setAutoDefault(False)
self.searchButton.clicked.connect(self.searchBookList)
self.layout.addWidget(self.searchButton, 2, buttonColumnNumber)
buttonColumnWidths.append(
self.layout.itemAtPosition(2,
buttonColumnNumber).sizeHint().width())
# The main book list
self.library_view = QTableView(self)
self.library_view.setAlternatingRowColors(True)
self.library_view.setModel(self.searchproxymodel)
self.library_view.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.library_view.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
self.library_view.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
self.library_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.resizeAllLibraryViewLinesToHeaderHeight()
self.library_view.resizeColumnsToContents()
self.layout.addWidget(self.library_view, 3, 0, 3,
buttonColumnNumber + 1)
self.hideNewsCheckbox = QCheckBox('Hide Newspapers', self)
self.hideNewsCheckbox.clicked.connect(self.setHideNewspapers)
self.hideNewsCheckbox.setChecked(prefs['hideNewspapers'])
self.layout.addWidget(self.hideNewsCheckbox, 6, 0, 1, 3)
self.hideBooksAlreadyInLibraryCheckbox = QCheckBox(
'Hide books already in library', self)
self.hideBooksAlreadyInLibraryCheckbox.clicked.connect(
self.setHideBooksAlreadyInLibrary)
self.hideBooksAlreadyInLibraryCheckbox.setChecked(
prefs['hideBooksAlreadyInLibrary'])
self.layout.addWidget(self.hideBooksAlreadyInLibraryCheckbox, 7, 0, 1,
3)
# Let the checkbox initial state control the filtering
self.model.setFilterBooksThatAreNewspapers(
self.hideNewsCheckbox.isChecked())
self.model.setFilterBooksThatAreAlreadyInLibrary(
self.hideBooksAlreadyInLibraryCheckbox.isChecked())
self.downloadButton = QPushButton('Download selected books', self)
self.downloadButton.setAutoDefault(False)
self.downloadButton.clicked.connect(self.downloadSelectedBooks)
self.layout.addWidget(self.downloadButton, 6, buttonColumnNumber)
buttonColumnWidths.append(
self.layout.itemAtPosition(6,
buttonColumnNumber).sizeHint().width())
self.fixTimestampButton = QPushButton('Fix timestamps of selection',
self)
self.fixTimestampButton.setAutoDefault(False)
self.fixTimestampButton.clicked.connect(self.fixBookTimestamps)
self.layout.addWidget(self.fixTimestampButton, 7, buttonColumnNumber)
buttonColumnWidths.append(
self.layout.itemAtPosition(7,
buttonColumnNumber).sizeHint().width())
# Make all columns of the grid layout the same width as the button column
buttonColumnWidth = max(buttonColumnWidths)
for columnNumber in range(0, buttonColumnNumber):
self.layout.setColumnMinimumWidth(columnNumber, buttonColumnWidth)
# Make sure the first column isn't wider than the labels it holds
labelColumnWidth = max(labelColumnWidths)
self.layout.setColumnMinimumWidth(0, labelColumnWidth)
self.resize(self.sizeHint())
def __init__(self,
settings,
all_formats,
supports_subdirs,
must_read_metadata,
supports_use_author_sort,
extra_customization_message,
device,
extra_customization_choices=None):
QWidget.__init__(self)
Ui_ConfigWidget.__init__(self)
self.setupUi(self)
self.settings = settings
all_formats = set(all_formats)
self.calibre_known_formats = device.FORMATS
try:
self.device_name = device.get_gui_name()
except TypeError:
self.device_name = getattr(device, 'gui_name', None) or _('Device')
if device.USER_CAN_ADD_NEW_FORMATS:
all_formats = set(all_formats) | set(BOOK_EXTENSIONS)
format_map = settings.format_map
disabled_formats = list(set(all_formats).difference(format_map))
for format in format_map + list(sorted(disabled_formats)):
item = QListWidgetItem(format, self.columns)
item.setData(Qt.UserRole, (format))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable
| Qt.ItemIsSelectable)
item.setCheckState(Qt.Checked if format in
format_map else Qt.Unchecked)
self.column_up.clicked.connect(self.up_column)
self.column_down.clicked.connect(self.down_column)
if device.HIDE_FORMATS_CONFIG_BOX:
self.groupBox.hide()
if supports_subdirs:
self.opt_use_subdirs.setChecked(self.settings.use_subdirs)
else:
self.opt_use_subdirs.hide()
if not must_read_metadata:
self.opt_read_metadata.setChecked(self.settings.read_metadata)
else:
self.opt_read_metadata.hide()
if supports_use_author_sort:
self.opt_use_author_sort.setChecked(self.settings.use_author_sort)
else:
self.opt_use_author_sort.hide()
if extra_customization_message:
extra_customization_choices = extra_customization_choices or {}
def parse_msg(m):
msg, _, tt = m.partition(':::') if m else ('', '', '')
return msg.strip(), textwrap.fill(tt.strip(), 100)
if isinstance(extra_customization_message, list):
self.opt_extra_customization = []
if len(extra_customization_message) > 6:
row_func = lambda x, y: ((x / 2) * 2) + y
col_func = lambda x: x % 2
else:
row_func = lambda x, y: x * 2 + y
col_func = lambda x: 0
for i, m in enumerate(extra_customization_message):
label_text, tt = parse_msg(m)
if not label_text:
self.opt_extra_customization.append(None)
continue
if isinstance(settings.extra_customization[i], bool):
self.opt_extra_customization.append(
QCheckBox(label_text))
self.opt_extra_customization[-1].setToolTip(tt)
self.opt_extra_customization[i].setChecked(
bool(settings.extra_customization[i]))
elif i in extra_customization_choices:
cb = QComboBox(self)
self.opt_extra_customization.append(cb)
l = QLabel(label_text)
l.setToolTip(tt), cb.setToolTip(tt), l.setBuddy(
cb), cb.setToolTip(tt)
for li in sorted(extra_customization_choices[i]):
self.opt_extra_customization[i].addItem(li)
cb.setCurrentIndex(
max(0,
cb.findText(settings.extra_customization[i])))
else:
self.opt_extra_customization.append(QLineEdit(self))
l = QLabel(label_text)
l.setToolTip(tt)
self.opt_extra_customization[i].setToolTip(tt)
l.setBuddy(self.opt_extra_customization[i])
l.setWordWrap(True)
self.opt_extra_customization[i].setText(
settings.extra_customization[i])
self.opt_extra_customization[i].setCursorPosition(0)
self.extra_layout.addWidget(l, row_func(i, 0),
col_func(i))
self.extra_layout.addWidget(
self.opt_extra_customization[i], row_func(i, 1),
col_func(i))
else:
self.opt_extra_customization = QLineEdit()
label_text, tt = parse_msg(extra_customization_message)
l = QLabel(label_text)
l.setToolTip(tt)
l.setBuddy(self.opt_extra_customization)
l.setWordWrap(True)
if settings.extra_customization:
self.opt_extra_customization.setText(
settings.extra_customization)
self.opt_extra_customization.setCursorPosition(0)
self.opt_extra_customization.setCursorPosition(0)
self.extra_layout.addWidget(l, 0, 0)
self.extra_layout.addWidget(self.opt_extra_customization, 1, 0)
self.opt_save_template.setText(settings.save_template)
def __init__(self, gui, icon, do_user_config):
QDialog.__init__(self, gui)
self.gui = gui
self.do_user_config = do_user_config
# The current database shown in the GUI
# db is an instance of the class LibraryDatabase2 from database.py
# This class has many, many methods that allow you to do a lot of
# things.
self.db = gui.current_db
self.l = QVBoxLayout()
self.setLayout(self.l)
# Label
self.labelText = QLabel('Use "and" and "or" for the search.')
self.l.addWidget(self.labelText)
# Title
self.setWindowTitle('Recoll Full Text Search')
self.setWindowIcon(icon)
# Search window
self.searchTextWindow = QComboBox()
self.searchTextWindow.setEditable(True)
self.l.addWidget(self.searchTextWindow)
self.searchTextWindow.setFocus()
self.searchTextWindow.setInsertPolicy(QComboBox.NoInsert)
self.searchTextWindow.setDuplicatesEnabled(False)
#Completer for the seach window
self.completer = QCompleter()
self.completer.setCompletionMode( QCompleter.UnfilteredPopupCompletion )
self.searchTextWindow.setCompleter(self.completer)
# output window
self.outputWindow = QLabel()
self.l.addWidget(self.outputWindow)
# search button 1
self.doSearchButton = QPushButton('Search and replace the filter', self)
self.doSearchButton.clicked.connect(self.recollSearchNew)
self.l.addWidget(self.doSearchButton)
self.doSearchButton.setDefault(True)
# search button 2
self.doSearchButton = QPushButton('Search and add to filter', self)
self.doSearchButton.clicked.connect(self.recollSearchAdd)
self.l.addWidget(self.doSearchButton)
# update database button 1
self.updateDatabaseButton = QPushButton('Update recoll database', self)
self.updateDatabaseButton.clicked.connect(self.updateDatabase)
self.l.addWidget(self.updateDatabaseButton)
# update database button 2
self.newDatabaseButton = QPushButton('Make new recoll database', self)
self.newDatabaseButton.clicked.connect(self.newDatabase)
self.l.addWidget(self.newDatabaseButton)
# config button
self.configButton = QPushButton('Configure this plugin', self)
self.configButton.clicked.connect(self.config)
self.l.addWidget(self.configButton)
# about button
self.aboutButton = QPushButton('About', self)
self.aboutButton.clicked.connect(self.about)
self.l.addWidget(self.aboutButton)
self.resize(self.sizeHint())
def __init__(self, gui, existing_names, editing=None):
QDialog.__init__(self, gui)
self.gui = gui
self.existing_names = existing_names
if editing:
self.setWindowTitle(_('Edit Virtual library'))
else:
self.setWindowTitle(_('Create Virtual library'))
self.setWindowIcon(QIcon(I('lt.png')))
gl = QGridLayout()
self.setLayout(gl)
self.la1 = la1 = QLabel(_('Virtual library &name:'))
gl.addWidget(la1, 0, 0)
self.vl_name = QComboBox()
self.vl_name.setEditable(True)
self.vl_name.lineEdit().setMaxLength(MAX_VIRTUAL_LIBRARY_NAME_LENGTH)
la1.setBuddy(self.vl_name)
gl.addWidget(self.vl_name, 0, 1)
self.editing = editing
self.saved_searches_label = sl = QTextBrowser(self)
sl.viewport().setAutoFillBackground(False)
gl.addWidget(sl, 2, 0, 1, 2)
self.la2 = la2 = QLabel(_('&Search expression:'))
gl.addWidget(la2, 1, 0)
self.vl_text = QLineEdit()
self.vl_text.textChanged.connect(self.search_text_changed)
la2.setBuddy(self.vl_text)
gl.addWidget(self.vl_text, 1, 1)
# Trigger the textChanged signal to initialize the saved searches box
self.vl_text.setText(' ')
self.vl_text.setText(_build_full_search_string(self.gui))
self.sl = sl = QLabel('<p>'+_('Create a Virtual library based on: ')+
('<a href="author.{0}">{0}</a>, '
'<a href="tag.{1}">{1}</a>, '
'<a href="publisher.{2}">{2}</a>, '
'<a href="series.{3}">{3}</a>, '
'<a href="search.{4}">{4}</a>.').format(_('Authors'), _('Tags'),
_('Publishers'), ngettext('Series', 'Series', 2), _('Saved searches')))
sl.setWordWrap(True)
sl.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
sl.linkActivated.connect(self.link_activated)
gl.addWidget(sl, 3, 0, 1, 2)
gl.setRowStretch(3,10)
self.hl = hl = QLabel(_('''
<h2>Virtual libraries</h2>
<p>With <i>Virtual libraries</i>, you can restrict calibre to only show
you books that match a search. When a Virtual library is in effect, calibre
behaves as though the library contains only the matched books. The Tag browser
display only the tags/authors/series/etc. that belong to the matched books and any searches
you do will only search within the books in the Virtual library. This
is a good way to partition your large library into smaller and easier to work with subsets.</p>
<p>For example you can use a Virtual library to only show you books with the tag <i>"Unread"</i>
or only books by <i>"My favorite author"</i> or only books in a particular series.</p>
<p>More information and examples are available in the
<a href="%s">User Manual</a>.</p>
''') % localize_user_manual_link('https://manual.calibre-ebook.com/virtual_libraries.html'))
hl.setWordWrap(True)
hl.setOpenExternalLinks(True)
hl.setFrameStyle(hl.StyledPanel)
gl.addWidget(hl, 0, 3, 4, 1)
bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
gl.addWidget(bb, 4, 0, 1, 0)
if editing:
db = self.gui.current_db
virt_libs = db.prefs.get('virtual_libraries', {})
for dex,vl in enumerate(sorted(virt_libs.keys(), key=sort_key)):
self.vl_name.addItem(vl, virt_libs.get(vl, ''))
if vl == editing:
self.vl_name.setCurrentIndex(dex)
self.original_index = dex
self.original_search = virt_libs.get(editing, '')
self.vl_text.setText(self.original_search)
self.new_name = editing
self.vl_name.currentIndexChanged[int].connect(self.name_index_changed)
self.vl_name.lineEdit().textEdited.connect(self.name_text_edited)
self.resize(self.sizeHint()+QSize(150, 25))
def add_listbox(self, name, items, callback):
self.listboxes[name] = listbox = QComboBox()
listbox.addItems(items)
listbox.currentIndexChanged.connect(callback)
self.layout.addWidget(listbox)
def __init__(self, fm, pref_name, parent=None):
QDialog.__init__(self, parent)
self.fm = fm
if pref_name == 'column_color_rules':
self.rule_kind = 'color'
rule_text = _('column coloring')
elif pref_name == 'column_icon_rules':
self.rule_kind = 'icon'
rule_text = _('column icon')
elif pref_name == 'cover_grid_icon_rules':
self.rule_kind = 'emblem'
rule_text = _('Cover grid emblem')
self.setWindowIcon(QIcon(I('format-fill-color.png')))
self.setWindowTitle(_('Create/edit a {0} rule').format(rule_text))
self.l = l = QGridLayout(self)
self.setLayout(l)
self.l1 = l1 = QLabel(_('Create a {0} rule by'
' filling in the boxes below').format(rule_text))
l.addWidget(l1, 0, 0, 1, 8)
self.f1 = QFrame(self)
self.f1.setFrameShape(QFrame.HLine)
l.addWidget(self.f1, 1, 0, 1, 8)
self.l2 = l2 = QLabel(_('Add the emblem:') if self.rule_kind == 'emblem' else _('Set the'))
l.addWidget(l2, 2, 0)
if self.rule_kind == 'color':
l.addWidget(QLabel(_('color')))
elif self.rule_kind == 'icon':
self.kind_box = QComboBox(self)
for tt, t in icon_rule_kinds:
self.kind_box.addItem(tt, t)
l.addWidget(self.kind_box, 2, 1)
self.kind_box.setToolTip(textwrap.fill(_(
'If you choose composed icons and multiple rules match, then all the'
' matching icons will be combined, otherwise the icon from the'
' first rule to match will be used.')))
else:
pass
self.l3 = l3 = QLabel(_('of the column:'))
l.addWidget(l3, 2, 2)
self.column_box = QComboBox(self)
l.addWidget(self.column_box, 2, 3)
self.l4 = l4 = QLabel(_('to'))
l.addWidget(l4, 2, 4)
if self.rule_kind == 'emblem':
l3.setVisible(False), self.column_box.setVisible(False), l4.setVisible(False)
def create_filename_box():
self.filename_box = f = QComboBox()
self.filenamebox_view = v = QListView()
v.setIconSize(QSize(32, 32))
self.filename_box.setView(v)
self.orig_filenamebox_view = f.view()
f.setMinimumContentsLength(20), f.setSizeAdjustPolicy(f.AdjustToMinimumContentsLengthWithIcon)
self.populate_icon_filenames()
if self.rule_kind == 'color':
self.color_box = ColorButton(parent=self)
self.color_label = QLabel('Sample text Sample text')
self.color_label.setTextFormat(Qt.RichText)
l.addWidget(self.color_box, 2, 5)
l.addWidget(self.color_label, 2, 6)
l.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding), 2, 7)
elif self.rule_kind == 'emblem':
create_filename_box()
self.update_filename_box()
self.filename_button = QPushButton(QIcon(I('document_open.png')),
_('&Add new image'))
l.addWidget(self.filename_box)
l.addWidget(self.filename_button, 2, 6)
l.addWidget(QLabel(_('(Images should be square-ish)')), 2, 7)
l.setColumnStretch(7, 10)
else:
create_filename_box()
vb = QVBoxLayout()
self.multiple_icon_cb = QCheckBox(_('Choose &more than one icon'))
vb.addWidget(self.multiple_icon_cb)
self.update_filename_box()
self.multiple_icon_cb.clicked.connect(self.multiple_box_clicked)
vb.addWidget(self.filename_box)
l.addLayout(vb, 2, 5)
self.filename_button = QPushButton(QIcon(I('document_open.png')),
_('&Add icon'))
l.addWidget(self.filename_button, 2, 6)
l.addWidget(QLabel(_('Icons should be square or landscape')), 2, 7)
l.setColumnStretch(7, 10)
self.l5 = l5 = QLabel(
_('Only if the following conditions are all satisfied:'))
l.addWidget(l5, 3, 0, 1, 7)
self.scroll_area = sa = QScrollArea(self)
sa.setMinimumHeight(300)
sa.setMinimumWidth(950)
sa.setWidgetResizable(True)
l.addWidget(sa, 4, 0, 1, 8)
self.add_button = b = QPushButton(QIcon(I('plus.png')),
_('Add &another condition'))
l.addWidget(b, 5, 0, 1, 8)
b.clicked.connect(self.add_blank_condition)
self.l6 = l6 = QLabel(_('You can disable a condition by'
' blanking all of its boxes'))
l.addWidget(l6, 6, 0, 1, 8)
self.bb = bb = QDialogButtonBox(
QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb, 7, 0, 1, 8)
if self.rule_kind != 'color':
self.remove_button = b = bb.addButton(_('&Remove icon'), bb.ActionRole)
b.setIcon(QIcon(I('minus.png')))
b.setMenu(QMenu())
b.setToolTip('<p>' + _('Remove a previously added icon. Note that doing so will cause rules that use it to stop working.'))
self.update_remove_button()
self.conditions_widget = QWidget(self)
sa.setWidget(self.conditions_widget)
self.conditions_widget.setLayout(QVBoxLayout())
self.conditions_widget.layout().setAlignment(Qt.AlignTop)
self.conditions = []
if self.rule_kind == 'color':
for b in (self.column_box, ):
b.setSizeAdjustPolicy(b.AdjustToMinimumContentsLengthWithIcon)
b.setMinimumContentsLength(15)
for key in sorted(displayable_columns(fm),
key=lambda(k): sort_key(fm[k]['name']) if k != color_row_key else 0):
if key == color_row_key and self.rule_kind != 'color':
continue
name = all_columns_string if key == color_row_key else fm[key]['name']
if name:
self.column_box.addItem(name, key)
self.column_box.setCurrentIndex(0)
if self.rule_kind == 'color':
self.color_box.color = '#000'
self.update_color_label()
self.color_box.color_changed.connect(self.update_color_label)
else:
self.rule_icon_files = []
self.filename_button.clicked.connect(self.filename_button_clicked)
self.resize(self.sizeHint())
def setupUi(self):
self.setObjectName("Dialog")
self.resize(1024, 700)
self.setWindowIcon(QIcon(I('convert.png')))
self.gridLayout = QGridLayout(self)
self.gridLayout.setObjectName("gridLayout")
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.input_label = QLabel(self)
self.input_label.setObjectName("input_label")
self.horizontalLayout.addWidget(self.input_label)
self.input_formats = QComboBox(self)
self.input_formats.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.input_formats.setMinimumContentsLength(5)
self.input_formats.setObjectName("input_formats")
self.horizontalLayout.addWidget(self.input_formats)
self.opt_individual_saved_settings = QCheckBox(self)
self.opt_individual_saved_settings.setObjectName(
"opt_individual_saved_settings")
self.horizontalLayout.addWidget(self.opt_individual_saved_settings)
spacerItem = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.label_2 = QLabel(self)
self.label_2.setObjectName("label_2")
self.horizontalLayout.addWidget(self.label_2)
self.output_formats = QComboBox(self)
self.output_formats.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.output_formats.setMinimumContentsLength(5)
self.output_formats.setObjectName("output_formats")
self.horizontalLayout.addWidget(self.output_formats)
self.gridLayout.addLayout(self.horizontalLayout, 0, 0, 1, 2)
self.groups = QListView(self)
sizePolicy = QSizePolicy(QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Expanding)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.groups.sizePolicy().hasHeightForWidth())
self.groups.setSizePolicy(sizePolicy)
self.groups.setTabKeyNavigation(True)
self.groups.setIconSize(QSize(48, 48))
self.groups.setWordWrap(True)
self.groups.setObjectName("groups")
self.gridLayout.addWidget(self.groups, 1, 0, 3, 1)
self.scrollArea = QScrollArea(self)
sizePolicy = QSizePolicy(QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Expanding)
sizePolicy.setHorizontalStretch(4)
sizePolicy.setVerticalStretch(10)
sizePolicy.setHeightForWidth(
self.scrollArea.sizePolicy().hasHeightForWidth())
self.scrollArea.setSizePolicy(sizePolicy)
self.scrollArea.setFrameShape(QFrame.Shape.NoFrame)
self.scrollArea.setLineWidth(0)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.page = QWidget()
self.page.setObjectName("page")
self.gridLayout.addWidget(self.scrollArea, 1, 1, 1, 1)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
self.buttonBox.setStandardButtons(
QDialogButtonBox.StandardButton.Cancel
| QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.RestoreDefaults)
self.buttonBox.setObjectName("buttonBox")
self.gridLayout.addWidget(self.buttonBox, 3, 1, 1, 1)
self.help = QTextEdit(self)
self.help.setReadOnly(True)
sizePolicy = QSizePolicy(QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.help.sizePolicy().hasHeightForWidth())
self.help.setSizePolicy(sizePolicy)
self.help.setMaximumHeight(80)
self.help.setObjectName("help")
self.gridLayout.addWidget(self.help, 2, 1, 1, 1)
self.input_label.setBuddy(self.input_formats)
self.label_2.setBuddy(self.output_formats)
self.input_label.setText(_("&Input format:"))
self.opt_individual_saved_settings.setText(
_("Use &saved conversion settings for individual books"))
self.label_2.setText(_("&Output format:"))
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def __init__(self, extra_customization_message,
extra_customization_choices, device_settings):
super(ExtraCustomization, self).__init__()
debug_print(
"ExtraCustomization.__init__ - extra_customization_message=",
extra_customization_message)
debug_print(
"ExtraCustomization.__init__ - extra_customization_choices=",
extra_customization_choices)
debug_print(
"ExtraCustomization.__init__ - device_settings.extra_customization=",
device_settings.extra_customization)
debug_print("ExtraCustomization.__init__ - device_settings=",
device_settings)
self.extra_customization_message = extra_customization_message
self.l = QVBoxLayout(self)
self.setLayout(self.l)
options_group = QGroupBox(_("Extra driver customization options"),
self)
self.l.addWidget(options_group)
self.extra_layout = QGridLayout()
self.extra_layout.setObjectName("extra_layout")
options_group.setLayout(self.extra_layout)
if extra_customization_message:
extra_customization_choices = extra_customization_choices or {}
def parse_msg(m):
msg, _, tt = m.partition(':::') if m else ('', '', '')
return msg.strip(), textwrap.fill(tt.strip(), 100)
if isinstance(extra_customization_message, list):
self.opt_extra_customization = []
if len(extra_customization_message) > 6:
row_func = lambda x, y: ((x // 2) * 2) + y
col_func = lambda x: x % 2
else:
row_func = lambda x, y: x * 2 + y
col_func = lambda x: 0
for i, m in enumerate(extra_customization_message):
label_text, tt = parse_msg(m)
if not label_text:
self.opt_extra_customization.append(None)
continue
if isinstance(device_settings.extra_customization[i],
bool):
self.opt_extra_customization.append(
QCheckBox(label_text))
self.opt_extra_customization[-1].setToolTip(tt)
self.opt_extra_customization[i].setChecked(
bool(device_settings.extra_customization[i]))
elif i in extra_customization_choices:
cb = QComboBox(self)
self.opt_extra_customization.append(cb)
l = QLabel(label_text)
l.setToolTip(tt), cb.setToolTip(tt), l.setBuddy(
cb), cb.setToolTip(tt)
for li in sorted(extra_customization_choices[i]):
self.opt_extra_customization[i].addItem(li)
cb.setCurrentIndex(
max(
0,
cb.findText(
device_settings.extra_customization[i])))
else:
self.opt_extra_customization.append(QLineEdit(self))
l = QLabel(label_text)
l.setToolTip(tt)
self.opt_extra_customization[i].setToolTip(tt)
l.setBuddy(self.opt_extra_customization[i])
l.setWordWrap(True)
self.opt_extra_customization[i].setText(
device_settings.extra_customization[i])
self.opt_extra_customization[i].setCursorPosition(0)
self.extra_layout.addWidget(l, row_func(i + 2, 0),
col_func(i))
self.extra_layout.addWidget(
self.opt_extra_customization[i], row_func(i + 2, 1),
col_func(i))
spacerItem1 = QSpacerItem(10, 10, QSizePolicy.Policy.Minimum,
QSizePolicy.Policy.Expanding)
self.extra_layout.addItem(spacerItem1, row_func(i + 2 + 2, 1),
0, 1, 2)
self.extra_layout.setRowStretch(row_func(i + 2 + 2, 1), 2)
else:
self.opt_extra_customization = QLineEdit()
label_text, tt = parse_msg(extra_customization_message)
l = QLabel(label_text)
l.setToolTip(tt)
l.setBuddy(self.opt_extra_customization)
l.setWordWrap(True)
if device_settings.extra_customization:
self.opt_extra_customization.setText(
device_settings.extra_customization)
self.opt_extra_customization.setCursorPosition(0)
self.opt_extra_customization.setCursorPosition(0)
self.extra_layout.addWidget(l, 0, 0)
self.extra_layout.addWidget(self.opt_extra_customization, 1, 0)
def __init__(self, parent_dialog, plugin_action):
self.parent_dialog = parent_dialog
self.plugin_action = plugin_action
QWidget.__init__(self)
self.l = QVBoxLayout()
self.setLayout(self.l)
label = QLabel('<b>' + _('Standard Columns:') + '</b>')
label.setWordWrap(True)
self.l.addWidget(label)
self.l.addSpacing(5)
self.firstseries = QCheckBox(_('Take Series from first book'), self)
self.firstseries.setToolTip(
_('''If set, the Series name and index from the first book will be set on the merged book.'''
))
self.firstseries.setChecked(prefs['firstseries'])
self.l.addWidget(self.firstseries)
self.l.addSpacing(5)
label = QLabel('<b>' + _('Custom Columns:') + '</b>')
label.setWordWrap(True)
self.l.addWidget(label)
label = QLabel(
_("If you have custom columns defined, they will be listed below. Choose how you would like these columns handled."
))
label.setWordWrap(True)
self.l.addWidget(label)
self.l.addSpacing(5)
scrollable = QScrollArea()
scrollcontent = QWidget()
scrollable.setWidget(scrollcontent)
scrollable.setWidgetResizable(True)
self.l.addWidget(scrollable)
self.sl = QVBoxLayout()
scrollcontent.setLayout(self.sl)
self.custcol_dropdowns = {}
custom_columns = self.plugin_action.gui.library_view.model(
).custom_columns
grid = QGridLayout()
self.sl.addLayout(grid)
row = 0
for key, column in custom_columns.iteritems():
if column['datatype'] in permitted_values:
# logger.debug("\n============== %s ===========\n"%key)
# for (k,v) in column.iteritems():
# logger.debug("column['%s'] => %s"%(k,v))
label = QLabel('%s(%s)' % (column['name'], key))
label.setToolTip(
_("Set this %s column on new merged books...") %
column['datatype'])
grid.addWidget(label, row, 0)
dropdown = QComboBox(self)
dropdown.addItem('', 'none')
for md in permitted_values[column['datatype']]:
# tags-like column also 'text'
if md == 'union' and not column['is_multiple']:
continue
if md == 'concat' and column['is_multiple']:
continue
dropdown.addItem(titleLabels[md], md)
self.custcol_dropdowns[key] = dropdown
if key in prefs['custom_cols']:
dropdown.setCurrentIndex(
dropdown.findData(prefs['custom_cols'][key]))
dropdown.setToolTip(
_("How this column will be populated by default."))
grid.addWidget(dropdown, row, 1)
row += 1
self.sl.insertStretch(-1)
def __init__(self, main, channels, default_channel=None):
super(ChannelAddWidget, self).__init__()
self.setObjectName("ChannelAddWidget")
self.main_win = main
self.channels = channels
self.default_channel = default_channel
self.channel = {}
self.linedit_list = []
self.game = self.main_win.games[self.main_win.game_index]
combox_items = os.listdir(Utils.get_full_path('channelsdk'))
v_layout = QVBoxLayout()
v_layout.addSpacing(30)
select_channel_combox = QComboBox()
select_channel_combox.addItems(combox_items)
select_channel_combox.activated[str].connect(self.select_channel)
v_layout.addWidget(select_channel_combox, alignment=Qt.AlignHCenter)
v_layout.addSpacing(30)
h_layout1 = QHBoxLayout()
form_layout1 = QFormLayout()
form_layout1.setContentsMargins(10, 10, 10, 0)
game_appid_value = QLabel(self.game['id'])
form_layout1.addRow("游戏ID：", game_appid_value)
game_appid_value.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.channel_id_value = QLineEdit()
self.channel_id_value.setPlaceholderText("必填参数")
form_layout1.addRow("渠道ID：", self.channel_id_value)
self.game_name_value = QLineEdit()
self.game_name_value.setText(self.game['name'])
form_layout1.addRow("游戏名称：", self.game_name_value)
self.game_package_value = QLineEdit()
form_layout1.addRow("游戏包名：", self.game_package_value)
self.game_vcode_value = QLineEdit()
form_layout1.addRow("游戏版本号：", self.game_vcode_value)
self.game_vname_value = QLineEdit()
form_layout1.addRow("游戏版本名：", self.game_vname_value)
self.debug_value = QLineEdit("false")
form_layout1.addRow("打印日志：", self.debug_value)
h_layout1.addLayout(form_layout1)
self.form_layout2 = QFormLayout()
self.form_layout2.setContentsMargins(10, 10, 10, 0)
h_layout1.addLayout(self.form_layout2)
v_layout.addLayout(h_layout1)
h_layout2 = QHBoxLayout()
back_btn = QPushButton("返 回")
back_btn.setFixedWidth(100)
back_btn.clicked.connect(self.back)
h_layout2.addWidget(back_btn, alignment=Qt.AlignLeft)
add_btn = QPushButton("添 加")
add_btn.setFixedWidth(100)
add_btn.clicked.connect(self.add)
h_layout2.addWidget(add_btn, alignment=Qt.AlignRight)
v_layout.addSpacing(50)
v_layout.addLayout(h_layout2)
self.setLayout(v_layout)
# 默认松鼠SDK
select_channel_combox.setCurrentText("songshu")
self.select_channel("songshu")
def setup_ui(self, ):
layout = QVBoxLayout(self)
self.setLayout(layout)
help_layout = QHBoxLayout()
layout.addLayout(help_layout)
# Add hyperlink to a help file at the right. We will replace the correct name when it is clicked.
help_label = QLabel('<a href="http://www.foo.com/">Plugin Help</a>',
self)
help_label.setTextInteractionFlags(Qt.LinksAccessibleByMouse
| Qt.LinksAccessibleByKeyboard)
help_label.setAlignment(Qt.AlignRight)
help_label.linkActivated.connect(self.help_link_activated)
help_layout.addWidget(help_label)
self.edu_quotes = QCheckBox(_('Smarten Quotation marks'), self)
layout.addWidget(self.edu_quotes)
self.edu_quotes.setChecked(self.prefs['edu_quotes'])
self.edu_quotes.stateChanged.connect(self.quotes_gui_changes)
exceptions_group_box = QGroupBox('', self)
layout.addWidget(exceptions_group_box)
exceptions_group_box_layout = QVBoxLayout()
exceptions_group_box.setLayout(exceptions_group_box_layout)
self.use_file = QCheckBox(_('Use custom apostrophe exceptions file'),
self)
exceptions_group_box_layout.addWidget(self.use_file)
if not self.edu_quotes.isChecked():
self.use_file.setDisabled(True)
else:
self.use_file.setChecked(self.prefs['use_file'])
self.use_file.stateChanged.connect(self.use_file_gui_changes)
path_layout = QHBoxLayout()
exceptions_group_box_layout.addLayout(path_layout)
self.file_path = QLineEdit('', self)
if not self.edu_quotes.isChecked() and not self.use_file.isChecked():
self.file_path.setReadOnly(True)
else:
self.file_path.setText(self.prefs['file_path'])
self.file_path.setReadOnly(True)
path_layout.addWidget(self.file_path)
self.file_button = QPushButton('...', self)
self.file_button.clicked.connect(self.getFile)
path_layout.addWidget(self.file_button)
if not self.edu_quotes.isChecked() and not self.use_file.isChecked():
self.file_button.setDisabled(True)
combo_layout = QVBoxLayout()
layout.addLayout(combo_layout)
label = QLabel(_('(em|en)-dash settings'), self)
combo_layout.addWidget(label)
self.dashes_combo = QComboBox()
combo_layout.addWidget(self.dashes_combo)
values = [
_('Do not educate dashes'),
_('-- = emdash (no endash support)'),
_('-- = emdash | --- = endash'),
_('--- = emdash | -- = endash')
]
self.dashes_combo.addItems(values)
self.dashes_combo.setCurrentIndex(self.prefs['dashes'])
# self.dashes_combo.currentIndexChanged.connect(self.update_gui)
self.ellipses = QCheckBox(_('Smarten ellipses'), self)
layout.addWidget(self.ellipses)
self.ellipses.setChecked(self.prefs['ellipses'])
self.unicode = QCheckBox(
_('Educate with unicode characters (instead of entities)'), self)
layout.addWidget(self.unicode)
self.unicode.setChecked(self.prefs['unicode'])
layout.addSpacing(10)
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self._ok_clicked)
button_box.rejected.connect(self.reject)
layout.addWidget(button_box)
