def hyperlink_dialog(self):
dialog = QDialog(self.parent_window)
dialog.setWindowTitle("Create a hyperlink")
dialog.resize(DIALOG_SIZE_X, DIALOG_SIZE_Y)
ok_button_anchor = QPushButton("&OK", dialog)
ok_button_anchor.setEnabled(False)
ok_button_anchor.clicked.connect(
lambda: self.insert_anchor(url_edit.text(), urltext_edit.text()))
ok_button_anchor.clicked.connect(dialog.hide)
ok_button_anchor.setAutoDefault(True)
cancel_button_anchor = QPushButton("&Cancel", dialog)
cancel_button_anchor.clicked.connect(dialog.hide)
cancel_button_anchor.setAutoDefault(True)
url_label = QLabel("Link to:")
url_edit = QLineEdit()
url_edit.setPlaceholderText("URL")
url_edit.textChanged.connect(lambda: self.enable_ok_button(
ok_button_anchor, url_edit.text(), urltext_edit.text()))
urltext_label = QLabel("Text to display:")
urltext_edit = QLineEdit()
urltext_edit.setPlaceholderText("Text")
urltext_edit.textChanged.connect(lambda: self.enable_ok_button(
ok_button_anchor, url_edit.text(), urltext_edit.text()))
button_box = QHBoxLayout()
button_box.addStretch(1)
button_box.addWidget(cancel_button_anchor)
button_box.addWidget(ok_button_anchor)
dialog_vbox = QVBoxLayout()
dialog_vbox.addWidget(url_label)
dialog_vbox.addWidget(url_edit)
dialog_vbox.addWidget(urltext_label)
dialog_vbox.addWidget(urltext_edit)
dialog_vbox.addLayout(button_box)
dialog.setLayout(dialog_vbox)
# if user already selected text, put it in urltext_edit
if self.selected_text:
if self.selected_is_url:
url_edit.setText(self.selected_text)
urltext_edit.setFocus()
else:
urltext_edit.setText(self.selected_text)
url_edit.setFocus()
dialog.exec()
def onCheckMediaDB(self):
self.progress.start(immediate=True)
(nohave, unused, warnings) = self.col.media.check()
self.progress.finish()
# generate report
report = ""
if warnings:
report += "\n".join(warnings) + "\n"
if unused:
if report:
report += "\n\n\n"
report += _(
"In media folder but not used by any cards:")
report += "\n" + "\n".join(unused)
if nohave:
if report:
report += "\n\n\n"
report += _(
"Used on cards but missing from media folder:")
report += "\n" + "\n".join(nohave)
if not report:
tooltip(_("No unused or missing files found."))
return
# show report and offer to delete
diag = QDialog(self)
diag.setWindowTitle("Anki")
layout = QVBoxLayout(diag)
diag.setLayout(layout)
text = QTextEdit()
text.setReadOnly(True)
text.setPlainText(report)
layout.addWidget(text)
box = QDialogButtonBox(QDialogButtonBox.Close)
layout.addWidget(box)
if unused:
b = QPushButton(_("Delete Unused Files"))
b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.ActionRole)
b.clicked.connect(
lambda c, u=unused, d=diag: self.deleteUnused(u, d))
box.rejected.connect(diag.reject)
diag.setMinimumHeight(400)
diag.setMinimumWidth(500)
restoreGeom(diag, "checkmediadb")
diag.exec_()
saveGeom(diag, "checkmediadb")
def setupButtons(self):
l = self.buttons = QHBoxLayout()
help = QPushButton(_("Help"))
help.setAutoDefault(False)
l.addWidget(help)
help.clicked.connect(self.onHelp)
l.addStretch()
addField = QPushButton(_("Add Field"))
addField.setAutoDefault(False)
l.addWidget(addField)
addField.clicked.connect(self.onAddField)
if not self._isCloze():
flip = QPushButton(_("Flip"))
flip.setAutoDefault(False)
l.addWidget(flip)
flip.clicked.connect(self.onFlip)
l.addStretch()
close = QPushButton(_("Close"))
close.setAutoDefault(False)
l.addWidget(close)
close.clicked.connect(self.accept)
class MediaSyncDialog(QDialog):
silentlyClose = True
def __init__(self,
mw: aqt.main.AnkiQt,
syncer: MediaSyncer,
close_when_done: bool = False) -> None:
super().__init__(mw)
self.mw = mw
self._syncer = syncer
self._close_when_done = close_when_done
self.form = aqt.forms.synclog.Ui_Dialog()
self.form.setupUi(self)
self.setWindowTitle(tr(TR.SYNC_MEDIA_LOG_TITLE))
disable_help_button(self)
self.abort_button = QPushButton(tr(TR.SYNC_ABORT_BUTTON))
qconnect(self.abort_button.clicked, self._on_abort)
self.abort_button.setAutoDefault(False)
self.form.buttonBox.addButton(self.abort_button,
QDialogButtonBox.ActionRole)
self.abort_button.setHidden(not self._syncer.is_syncing())
gui_hooks.media_sync_did_progress.append(self._on_log_entry)
gui_hooks.media_sync_did_start_or_stop.append(self._on_start_stop)
self.form.plainTextEdit.setPlainText("\n".join(
self._entry_to_text(x) for x in syncer.entries()))
self.form.plainTextEdit.moveCursor(QTextCursor.End)
self.show()
def reject(self) -> None:
if self._close_when_done and self._syncer.is_syncing():
# closing while syncing on close starts an abort
self._on_abort()
return
aqt.dialogs.markClosed("sync_log")
QDialog.reject(self)
def reopen(self, mw, syncer, close_when_done: bool = False) -> None:
self._close_when_done = close_when_done
self.show()
def _on_abort(self, *args) -> None:
self._syncer.abort()
self.abort_button.setHidden(True)
def _time_and_text(self, stamp: int, text: str) -> str:
asctime = time.asctime(time.localtime(stamp))
return f"{asctime}: {text}"
def _entry_to_text(self, entry: LogEntryWithTime):
if isinstance(entry.entry, str):
txt = entry.entry
elif isinstance(entry.entry, MediaSyncProgress):
txt = self._logentry_to_text(entry.entry)
else:
assert_exhaustive(entry.entry)
return self._time_and_text(entry.time, txt)
def _logentry_to_text(self, e: MediaSyncProgress) -> str:
return f"{e.added}, {e.removed}, {e.checked}"
def _on_log_entry(self, entry: LogEntryWithTime):
self.form.plainTextEdit.appendPlainText(self._entry_to_text(entry))
if not self._syncer.is_syncing():
self.abort_button.setHidden(True)
def _on_start_stop(self, running: bool) -> None:
if not running and self._close_when_done:
aqt.dialogs.markClosed("sync_log")
self._close_when_done = False
self.close()
class AddCards(QDialog):
def __init__(self, mw):
QDialog.__init__(self, None, Qt.Window)
mw.setupDialogGC(self)
self.mw = mw
self.form = aqt.forms.addcards.Ui_Dialog()
self.form.setupUi(self)
self.setWindowTitle(_("Add"))
self.setMinimumHeight(300)
self.setMinimumWidth(400)
self.setupChoosers()
self.setupEditor()
self.setupButtons()
self.onReset()
self.history = []
restoreGeom(self, "add")
addHook('reset', self.onReset)
addHook('currentModelChanged', self.onModelChange)
addCloseShortcut(self)
self.show()
def setupEditor(self):
self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea, self,
True)
def setupChoosers(self):
self.modelChooser = aqt.modelchooser.ModelChooser(
self.mw, self.form.modelArea)
self.deckChooser = aqt.deckchooser.DeckChooser(self.mw,
self.form.deckArea)
def helpRequested(self):
openHelp("addingnotes")
def setupButtons(self):
bb = self.form.buttonBox
ar = QDialogButtonBox.ActionRole
# add
self.addButton = bb.addButton(_("Add"), ar)
self.addButton.clicked.connect(self.addCards)
self.addButton.setShortcut(QKeySequence("Ctrl+Return"))
self.addButton.setToolTip(shortcut(_("Add (shortcut: ctrl+enter)")))
# close
self.closeButton = QPushButton(_("Close"))
self.closeButton.setAutoDefault(False)
bb.addButton(self.closeButton, QDialogButtonBox.RejectRole)
# help
self.helpButton = QPushButton(_("Help"), clicked=self.helpRequested)
self.helpButton.setAutoDefault(False)
bb.addButton(self.helpButton, QDialogButtonBox.HelpRole)
# history
b = bb.addButton(_("History") + " " + downArrow(), ar)
if isMac:
sc = "Ctrl+Shift+H"
else:
sc = "Ctrl+H"
b.setShortcut(QKeySequence(sc))
b.setToolTip(_("Shortcut: %s") % shortcut(sc))
b.clicked.connect(self.onHistory)
b.setEnabled(False)
self.historyButton = b
def setAndFocusNote(self, note):
self.editor.setNote(note, focusTo=0)
def onModelChange(self):
oldNote = self.editor.note
note = self.mw.col.newNote()
if oldNote:
oldFields = list(oldNote.keys())
newFields = list(note.keys())
for n, f in enumerate(note.model()['flds']):
fieldName = f['name']
try:
oldFieldName = oldNote.model()['flds'][n]['name']
except IndexError:
oldFieldName = None
# copy identical fields
if fieldName in oldFields:
note[fieldName] = oldNote[fieldName]
# set non-identical fields by field index
elif oldFieldName and oldFieldName not in newFields:
try:
note.fields[n] = oldNote.fields[n]
except IndexError:
pass
self.removeTempNote(oldNote)
self.editor.setNote(note)
def onReset(self, model=None, keep=False):
oldNote = self.editor.note
note = self.mw.col.newNote()
flds = note.model()['flds']
# copy fields from old note
if oldNote:
if not keep:
self.removeTempNote(oldNote)
for n in range(len(note.fields)):
try:
if not keep or flds[n]['sticky']:
note.fields[n] = oldNote.fields[n]
else:
note.fields[n] = ""
except IndexError:
break
self.setAndFocusNote(note)
def removeTempNote(self, note):
if not note or not note.id:
return
# we don't have to worry about cards; just the note
self.mw.col._remNotes([note.id])
def addHistory(self, note):
self.history.insert(0, note.id)
self.history = self.history[:15]
self.historyButton.setEnabled(True)
def onHistory(self):
m = QMenu(self)
for nid in self.history:
if self.mw.col.findNotes("nid:%s" % nid):
fields = self.mw.col.getNote(nid).fields
txt = htmlToTextLine(", ".join(fields))
if len(txt) > 30:
txt = txt[:30] + "..."
a = m.addAction(_("Edit \"%s\"") % txt)
a.triggered.connect(lambda b, nid=nid: self.editHistory(nid))
else:
a = m.addAction(_("(Note deleted)"))
a.setEnabled(False)
runHook("AddCards.onHistory", self, m)
m.exec_(self.historyButton.mapToGlobal(QPoint(0, 0)))
def editHistory(self, nid):
browser = aqt.dialogs.open("Browser", self.mw)
browser.form.searchEdit.lineEdit().setText("nid:%d" % nid)
browser.onSearchActivated()
def addNote(self, note):
note.model()['did'] = self.deckChooser.selectedId()
ret = note.dupeOrEmpty()
if ret == 1:
showWarning(_("The first field is empty."),
help="AddItems#AddError")
return
if '{{cloze:' in note.model()['tmpls'][0]['qfmt']:
if not self.mw.col.models._availClozeOrds(
note.model(), note.joinedFields(), False):
if not askUser(
_("You have a cloze deletion note type "
"but have not made any cloze deletions. Proceed?")):
return
cards = self.mw.col.addNote(note)
if not cards:
showWarning(_("""\
The input you have provided would make an empty \
question on all cards."""),
help="AddItems")
return
self.addHistory(note)
self.mw.requireReset()
return note
def addCards(self):
self.editor.saveNow(self._addCards)
def _addCards(self):
self.editor.saveAddModeVars()
note = self.editor.note
note = self.addNote(note)
if not note:
return
tooltip(_("Added"), period=500)
# stop anything playing
clearAudioQueue()
self.onReset(keep=True)
self.mw.col.autosave()
def keyPressEvent(self, evt):
"Show answer on RET or register answer."
if (evt.key() in (Qt.Key_Enter, Qt.Key_Return)
and self.editor.tags.hasFocus()):
evt.accept()
return
return QDialog.keyPressEvent(self, evt)
def reject(self):
self.ifCanClose(self._reject)
def _reject(self):
remHook('reset', self.onReset)
remHook('currentModelChanged', self.onModelChange)
clearAudioQueue()
self.removeTempNote(self.editor.note)
self.editor.cleanup()
self.modelChooser.cleanup()
self.deckChooser.cleanup()
self.mw.maybeReset()
saveGeom(self, "add")
aqt.dialogs.markClosed("AddCards")
QDialog.reject(self)
def ifCanClose(self, onOk):
def afterSave():
ok = (self.editor.fieldsAreBlank()
or askUser(_("Close and lose current input?")))
if ok:
onOk()
self.editor.saveNow(afterSave)
def closeWithCallback(self, cb):
def doClose():
self._reject()
cb()
self.ifCanClose(doClose)
class ModelChooser(QHBoxLayout):
def __init__(self, mw, widget, label=True):
QHBoxLayout.__init__(self)
self.widget = widget
self.mw = mw
self.deck = mw.col
self.label = label
self.setContentsMargins(0, 0, 0, 0)
self.setSpacing(8)
self.setupModels()
addHook('reset', self.onReset)
self.widget.setLayout(self)
def setupModels(self):
if self.label:
self.modelLabel = QLabel(_("Type"))
self.addWidget(self.modelLabel)
# models box
self.models = QPushButton()
#self.models.setStyleSheet("* { text-align: left; }")
self.models.setToolTip(shortcut(_("Change Note Type (Ctrl+N)")))
s = QShortcut(QKeySequence(_("Ctrl+N")),
self.widget,
activated=self.onModelChange)
self.models.setAutoDefault(False)
self.addWidget(self.models)
self.models.clicked.connect(self.onModelChange)
# layout
sizePolicy = QSizePolicy(QSizePolicy.Policy(7), QSizePolicy.Policy(0))
self.models.setSizePolicy(sizePolicy)
self.updateModels()
def cleanup(self):
remHook('reset', self.onReset)
def onReset(self):
self.updateModels()
def show(self):
self.widget.show()
def hide(self):
self.widget.hide()
def onEdit(self):
import aqt.models
aqt.models.Models(self.mw, self.widget)
def onModelChange(self):
from aqt.studydeck import StudyDeck
current = self.deck.models.current()['name']
# edit button
edit = QPushButton(_("Manage"), clicked=self.onEdit)
def nameFunc():
return sorted(self.deck.models.allNames())
ret = StudyDeck(self.mw,
names=nameFunc,
accept=_("Choose"),
title=_("Choose Note Type"),
help="_notes",
current=current,
parent=self.widget,
buttons=[edit],
cancel=True,
geomKey="selectModel")
if not ret.name:
return
m = self.deck.models.byName(ret.name)
self.deck.conf['curModel'] = m['id']
cdeck = self.deck.decks.current()
cdeck['mid'] = m['id']
self.deck.decks.save(cdeck)
runHook("currentModelChanged")
self.mw.reset()
def updateModels(self):
self.models.setText(self.deck.models.current()['name'])
def setup_evernote(self):
global icoEvernoteWeb
global imgEvernoteWeb
global elements
global evernote_query_last_updated
global evernote_pagination_current_page_spinner
def update_checkbox(setting):
if setting is DECKS.EVERNOTE_NOTEBOOK_INTEGRATION and not elements[DECKS.BASE].text():
return
if setting.get.startswith(QUERY.get):
update_evernote_query_visibilities()
setting.save(elements[setting].isChecked())
# mw.col.conf[setting] =
if setting is QUERY.USE_TAGS:
update_evernote_query_visibilities()
if setting is QUERY.LAST_UPDATED.USE:
evernote_query_last_updated_value_set_visibilities()
def create_checkbox(setting, label=" ", default_value=False, is_fixed_size=False, fixed_width=None):
if isinstance(label, bool):
default_value = label
label = " "
checkbox = QCheckBox(label, self)
sval = setting.fetch()
if not isinstance(sval, bool):
sval = default_value
checkbox.setChecked(sval)
# noinspection PyUnresolvedReferences
checkbox.stateChanged.connect(lambda: update_checkbox(setting))
if is_fixed_size or fixed_width:
checkbox.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
if fixed_width:
checkbox.setFixedWidth(fixed_width)
elements[setting] = checkbox
return checkbox
def create_checked_checkbox(*a, **kw):
kw['default_value'] = True
return create_checkbox(*a, **kw)
def update_text(setting, text):
text = text.strip()
setting.save(text)
if setting is DECKS.BASE:
update_anki_deck_visibilities()
if setting.get.startswith(QUERY.get):
if text:
use_key = getattr(QUERY, 'USE_' + setting.label.name)
elements[use_key].setChecked(True)
evernote_query_text_changed()
if setting is QUERY.SEARCH_TERMS:
update_evernote_query_visibilities()
def create_textbox(setting, default_value=""):
textbox = QLineEdit()
textbox.setText(setting.fetch(default_value))
textbox.connect(textbox,
SIGNAL("textEdited(QString)"),
lambda text: update_text(setting, text))
elements[setting] = textbox
return textbox
def add_query_row(setting, is_checked=False, **kw):
try:
default_value = setting.val
except:
default_value = ''
row_label = ' '.join(x.capitalize() for x in setting.replace('_', ' ').split())
hbox = QHBoxLayout()
hbox.addWidget(create_checkbox(getattr(QUERY, 'USE_' + setting),
default_value=is_checked, **kw))
hbox.addWidget(create_textbox(getattr(QUERY, setting), default_value))
form.addRow(row_label, hbox)
def gen_qt_hr():
vbox = QVBoxLayout()
hr = QFrame()
hr.setAutoFillBackground(True)
hr.setFrameShape(QFrame.HLine)
hr.setStyleSheet("QFrame { background-color: #0060bf; color: #0060bf; }")
hr.setFixedHeight(2)
vbox.addWidget(hr)
vbox.addSpacing(4)
return vbox
# Begin setup_evernote()
widget = QWidget()
layout = QVBoxLayout()
elements = {}
rm_log_path('Dicts\\')
evernote_query_last_updated = DictCaseInsensitive()
########################## QUERY ##########################
##################### QUERY: TEXTBOXES ####################
group = QGroupBox("EVERNOTE SEARCH OPTIONS:")
group.setStyleSheet('QGroupBox{ font-size: 10px; font-weight: bold; color: rgb(105, 170, 53);}')
form = QFormLayout()
form.addRow(gen_qt_hr())
# Show Generated Evernote Query Button
button_show_generated_evernote_query = QPushButton(icoEvernoteWeb, "Show Full Query", self)
button_show_generated_evernote_query.setAutoDefault(False)
button_show_generated_evernote_query.connect(button_show_generated_evernote_query,
SIGNAL("clicked()"),
handle_show_generated_evernote_query)
# Add Form Row for Match Any Terms
hbox = QHBoxLayout()
hbox.addWidget(create_checked_checkbox(QUERY.ANY, " Match Any Terms", is_fixed_size=True))
hbox.addWidget(button_show_generated_evernote_query)
form.addRow("<b>Search Parameters:</b>", hbox)
# Add Form Rows for Evernote Query Textboxes
for el in QUERY_TEXTBOXES:
add_query_row(el, 'TAGS' in el)
################### QUERY: LAST UPDATED ###################
# Evernote Query: Last Updated Type
evernote_query_last_updated.type = QComboBox()
evernote_query_last_updated.type.setStyleSheet(' QComboBox { color: rgb(45, 79, 201); font-weight: bold; } ')
evernote_query_last_updated.type.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
evernote_query_last_updated.type.addItems([u"Δ Day", u"Δ Week", u"Δ Month", u"Δ Year", "Date", "+ Time"])
evernote_query_last_updated.type.setCurrentIndex(QUERY.LAST_UPDATED.TYPE.fetch(EvernoteQueryLocationType.RelativeDay))
evernote_query_last_updated.type.activated.connect(update_evernote_query_last_updated_type)
# Evernote Query: Last Updated Type: Relative Date
evernote_query_last_updated.value.relative.spinner = EvernoteQueryLocationValueQSpinBox()
evernote_query_last_updated.value.relative.spinner.setVisible(False)
evernote_query_last_updated.value.relative.spinner.setStyleSheet(
" QSpinBox, EvernoteQueryLocationValueQSpinBox { font-weight: bold; color: rgb(173, 0, 0); } ")
evernote_query_last_updated.value.relative.spinner.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
evernote_query_last_updated.value.relative.spinner.connect(evernote_query_last_updated.value.relative.spinner,
SIGNAL("valueChanged(int)"),
update_evernote_query_last_updated_value_relative_spinner)
# Evernote Query: Last Updated Type: Absolute Date
evernote_query_last_updated.value.absolute.date = QDateEdit()
evernote_query_last_updated.value.absolute.date.setDisplayFormat('M/d/yy')
evernote_query_last_updated.value.absolute.date.setCalendarPopup(True)
evernote_query_last_updated.value.absolute.date.setVisible(False)
evernote_query_last_updated.value.absolute.date.setStyleSheet(
"QDateEdit { font-weight: bold; color: rgb(173, 0, 0); } ")
evernote_query_last_updated.value.absolute.date.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
evernote_query_last_updated.value.absolute.date.connect(evernote_query_last_updated.value.absolute.date,
SIGNAL("dateChanged(QDate)"),
update_evernote_query_last_updated_value_absolute_date)
# Evernote Query: Last Updated Type: Absolute DateTime
evernote_query_last_updated.value.absolute.datetime = QDateTimeEdit()
evernote_query_last_updated.value.absolute.datetime.setDisplayFormat('M/d/yy h:mm AP')
evernote_query_last_updated.value.absolute.datetime.setCalendarPopup(True)
evernote_query_last_updated.value.absolute.datetime.setVisible(False)
evernote_query_last_updated.value.absolute.datetime.setStyleSheet(
"QDateTimeEdit { font-weight: bold; color: rgb(173, 0, 0); } ")
evernote_query_last_updated.value.absolute.datetime.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
evernote_query_last_updated.value.absolute.datetime.connect(evernote_query_last_updated.value.absolute.datetime,
SIGNAL("dateTimeChanged(QDateTime)"),
update_evernote_query_last_updated_value_absolute_datetime)
# Evernote Query: Last Updated Type: Absolute Time
evernote_query_last_updated.value.absolute.time = QTimeEdit()
evernote_query_last_updated.value.absolute.time.setDisplayFormat('h:mm AP')
evernote_query_last_updated.value.absolute.time.setVisible(False)
evernote_query_last_updated.value.absolute.time.setStyleSheet(
"QTimeEdit { font-weight: bold; color: rgb(143, 0, 30); } ")
evernote_query_last_updated.value.absolute.time.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
evernote_query_last_updated.value.absolute.time.connect(evernote_query_last_updated.value.absolute.time,
SIGNAL("timeChanged(QTime)"),
update_evernote_query_last_updated_value_absolute_time)
# Create HBox for Separated Date & Time
hbox_datetime = QHBoxLayout()
hbox_datetime.addWidget(evernote_query_last_updated.value.absolute.date)
hbox_datetime.addWidget(evernote_query_last_updated.value.absolute.time)
# Evernote Query: Last Updated Type
evernote_query_last_updated.value.stacked_layout = QStackedLayout()
evernote_query_last_updated.value.stacked_layout.addWidget(evernote_query_last_updated.value.relative.spinner)
evernote_query_last_updated.value.stacked_layout.addItem(hbox_datetime)
# Add Form Row for Evernote Query: Last Updated
hbox = QHBoxLayout()
label = QLabel("Last Updated: ")
label.setMinimumWidth(SETTINGS.FORM.LABEL_MINIMUM_WIDTH.val)
hbox.addWidget(create_checkbox(QUERY.LAST_UPDATED.USE, is_fixed_size=True))
hbox.addWidget(evernote_query_last_updated.type)
hbox.addWidget(evernote_query_last_updated.value.relative.spinner)
hbox.addWidget(evernote_query_last_updated.value.absolute.date)
hbox.addWidget(evernote_query_last_updated.value.absolute.time)
form.addRow(label, hbox)
# Add Horizontal Row Separator
form.addRow(gen_qt_hr())
############################ PAGINATION ##########################
# Evernote Pagination: Current Page
evernote_pagination_current_page_spinner = QSpinBox()
evernote_pagination_current_page_spinner.setStyleSheet("QSpinBox { font-weight: bold; color: rgb(173, 0, 0); } ")
evernote_pagination_current_page_spinner.setPrefix("PAGE: ")
evernote_pagination_current_page_spinner.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
evernote_pagination_current_page_spinner.setValue(EVERNOTE.PAGINATION_CURRENT_PAGE.fetch(1))
evernote_pagination_current_page_spinner.connect(evernote_pagination_current_page_spinner,
SIGNAL("valueChanged(int)"),
update_evernote_pagination_current_page_spinner)
# Evernote Pagination: Automation
hbox = QHBoxLayout()
hbox.addWidget(create_checked_checkbox(EVERNOTE.AUTO_PAGING, " Automate", fixed_width=105))
hbox.addWidget(evernote_pagination_current_page_spinner)
# Add Form Row for Evernote Pagination
form.addRow("<b>Pagination:</b>", hbox)
# Add Query Form to Group Box
group.setLayout(form)
# Add Query Group Box to Main Layout
layout.addWidget(group)
########################## DECK ##########################
# Setup Group Box and Form
group = QGroupBox("ANKI NOTE OPTIONS:")
group.setStyleSheet('QGroupBox{ font-size: 10px; font-weight: bold; color: rgb(105, 170, 53);}')
form = QFormLayout()
# Add Horizontal Row Separator
form.addRow(gen_qt_hr())
# Add Form Row for Default Anki Deck
hbox = QHBoxLayout()
hbox.insertSpacing(0, 33)
hbox.addWidget(create_textbox(DECKS.BASE, DECKS.BASE_DEFAULT_VALUE))
label_deck = QLabel("<b>Anki Deck:</b>")
label_deck.setMinimumWidth(SETTINGS.FORM.LABEL_MINIMUM_WIDTH.val)
form.addRow(label_deck, hbox)
# Add Form Row for Evernote Notebook Integration
label_deck = QLabel("Evernote Notebook:")
label_deck.setMinimumWidth(SETTINGS.FORM.LABEL_MINIMUM_WIDTH.val)
form.addRow("", create_checked_checkbox(DECKS.EVERNOTE_NOTEBOOK_INTEGRATION, " Append Evernote Notebook"))
# Add Horizontal Row Separator
form.addRow(gen_qt_hr())
############################ TAGS ##########################
# Add Form Row for Evernote Tag Options
label = QLabel("<b>Evernote Tags:</b>")
label.setMinimumWidth(SETTINGS.FORM.LABEL_MINIMUM_WIDTH.val)
# Tags: Save To Anki Note
form.addRow(label, create_checkbox(TAGS.KEEP_TAGS, " Save To Anki Note", TAGS.KEEP_TAGS_DEFAULT_VALUE))
hbox = QHBoxLayout()
hbox.insertSpacing(0, 33)
hbox.addWidget(create_textbox(TAGS.TO_DELETE))
# Tags: Tags To Delete
form.addRow("Tags to Delete:", hbox)
form.addRow(" ", create_checkbox(TAGS.DELETE_EVERNOTE_QUERY_TAGS, " Also Delete Search Tags"))
# Add Horizontal Row Separator
form.addRow(gen_qt_hr())
############################ NOTE UPDATING ##########################
# Note Update Method
update_existing_notes = QComboBox()
update_existing_notes.setStyleSheet(
' QComboBox { color: #3b679e; font-weight: bold; } QComboBoxItem { color: #A40F2D; font-weight: bold; } ')
update_existing_notes.addItems(["Ignore Existing Notes", "Update In-Place",
"Delete and Re-Add"])
sval = ANKI.UPDATE_EXISTING_NOTES.fetch()
if not isinstance(sval, int):
sval = ANKI.UPDATE_EXISTING_NOTES.val
update_existing_notes.setCurrentIndex(sval)
update_existing_notes.activated.connect(update_update_existing_notes)
# Add Form Row for Note Update Method
hbox = QHBoxLayout()
hbox.insertSpacing(0, 33)
hbox.addWidget(update_existing_notes)
form.addRow("<b>Note Updating:</b>", hbox)
# Add Note Update Method Form to Group Box
group.setLayout(form)
# Add Note Update Method Group Box to Main Layout
layout.addWidget(group)
######################### UPDATE VISIBILITIES #######################
# Update Visibilities of Anki Deck Options
update_anki_deck_visibilities()
# Update Visibilities of Query Options
evernote_query_text_changed()
update_evernote_query_visibilities()
######################## ADD TO SETTINGS PANEL ######################
# Vertical Spacer
vertical_spacer = QSpacerItem(20, 0, QSizePolicy.Minimum, QSizePolicy.Expanding)
layout.addItem(vertical_spacer)
# Parent Widget
widget.setLayout(layout)
# New Tab
self.form.tabWidget.addTab(widget, "Anknotes")
