def insert_reviewer_more_action(self, m):
#self is Reviewer
a = m.addAction('Browse Creation of This Card')
a.setShortcut(QKeySequence("c"))
a.connect(a, SIGNAL("triggered()"), lambda s=self: browse_this_card(s))
a = m.addAction('Browse Creation of Last Card')
a.connect(a, SIGNAL("triggered()"), lambda s=self: browse_last_card(s))
def setup_evernote(self):
global evernote_default_deck
global evernote_default_tag
global evernote_tags_to_import
global keep_evernote_tags
global update_existing_notes
widget = QWidget()
layout = QVBoxLayout()
# Default Deck
evernote_default_deck_label = QLabel("Default Deck for imported Cards:")
evernote_default_deck = QLineEdit()
evernote_default_deck.setText(mw.col.conf.get(SETTING_DEFAULT_DECK, ""))
layout.insertWidget(int(layout.count()) + 1, evernote_default_deck_label)
layout.insertWidget(int(layout.count()) + 2, evernote_default_deck)
evernote_default_deck.connect(evernote_default_deck, SIGNAL("editingFinished()"), update_evernote_default_deck)
# Default Tag
evernote_default_tag_label = QLabel("Default Tag for imported Cards:")
evernote_default_tag = QLineEdit()
evernote_default_tag.setText(mw.col.conf.get(SETTING_DEFAULT_TAG, ""))
layout.insertWidget(int(layout.count()) + 1, evernote_default_tag_label)
layout.insertWidget(int(layout.count()) + 2, evernote_default_tag)
evernote_default_tag.connect(evernote_default_tag, SIGNAL("editingFinished()"), update_evernote_default_tag)
# Tags to Import
evernote_tags_to_import_label = QLabel("Evernote Tags to Import:")
evernote_tags_to_import = QLineEdit()
evernote_tags_to_import.setText(mw.col.conf.get(SETTING_TAGS_TO_IMPORT, ""))
layout.insertWidget(int(layout.count()) + 1, evernote_tags_to_import_label)
layout.insertWidget(int(layout.count()) + 2, evernote_tags_to_import)
evernote_tags_to_import.connect(evernote_tags_to_import,
SIGNAL("editingFinished()"),
update_evernote_tags_to_import)
# Keep Evernote Tags
keep_evernote_tags = QCheckBox("Keep Evernote Tags", self)
keep_evernote_tags.setChecked(mw.col.conf.get(SETTING_KEEP_TAGS, False))
keep_evernote_tags.stateChanged.connect(update_evernote_keep_tags)
layout.insertWidget(int(layout.count()) + 1, keep_evernote_tags)
# Update Existing Notes
update_existing_notes = QComboBox()
update_existing_notes.addItems(["Ignore Existing Notes", "Update Existing Notes In-Place",
"Delete and Re-Add Existing Notes"])
update_existing_notes.setCurrentIndex(mw.col.conf.get(SETTING_UPDATE_EXISTING_NOTES,
UpdateExistingNotes.UpdateNotesInPlace))
update_existing_notes.activated.connect(update_evernote_update_existing_notes)
layout.insertWidget(int(layout.count()) + 1, update_existing_notes)
# 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, "Evernote2AnkiMac")
def run(self):
try:
dbbuilder.build()
self.emit(SIGNAL("buildsuccess()"))
except Exception, e:
log.exception(
"Suppressed exception in database build process")
self.emit(SIGNAL("buildfailure(PyQt_PyObject)"),
sys.exc_info())
def create_menu():
u"""Set up the menu."""
mn = QMenu()
mn.setTitle("Nachschlagen")
mw.form.menuTools.addAction(mn.menuAction())
#
mw.form.menu_nachschlagen = mn
# add actions
if show_japanese:
# Maybe not show the Japanese actions.
wae = QAction(mw)
wae.setText("Japanisch bei Wadoku")
# wae.setShortcut("Ctrl+4")
mn.addAction(wae)
mw.connect(wae, SIGNAL("triggered()"), on_lookup_wadoku_expression)
wam = QAction(mw)
wam.setText("Deutsch bei Wadoku")
# wam.setShortcut("Ctrl+2")
mn.addAction(wam)
mw.connect(wam, SIGNAL("triggered()"), on_lookup_wadoku_meaning)
was = QAction(mw)
was.setText("Auswahl bei Wadoku")
mn.addAction(was)
mw.connect(was, SIGNAL("triggered()"), on_lookup_wadoku_selection)
if show_saiga:
# Personal taste: i like the Kanjilexikon better than the
# Saiga look up. So i like this switched off.
sae = QAction(mw)
sae.setText("Kanji bei Saiga")
#sae.setShortcut("Ctrl+4")
mn.addAction(sae)
mw.connect(sae, SIGNAL("triggered()"), on_lookup_saiga_expression)
sas = QAction(mw)
sas.setText("Kanjiauswahl bei Saiga")
mn.addAction(sas)
mw.connect(sas, SIGNAL("triggered()"), on_lookup_saiga_selection)
kle = QAction(mw)
kle.setText("Kanji bei Kanji-Lexikon")
# kle.setShortcut("Ctrl+4")
mn.addAction(kle)
mw.connect(kle, SIGNAL("triggered()"), on_lookup_kl_expression)
kls = QAction(mw)
kls.setText("Kanjiauswahl bei Kanji-Lexikon")
mn.addAction(kls)
mw.connect(kls, SIGNAL("triggered()"), on_lookup_kl_selection)
# Show these always.
fae = QAction(mw)
fae.setText("Ausdruck bei Forvo")
# fae.setShortcut("Ctrl+4")
mn.addAction(fae)
mw.connect(fae, SIGNAL("triggered()"), on_lookup_forvo_expression)
fas = QAction(mw)
fas.setText("Auswahl bei Forvo")
mn.addAction(fas)
mw.connect(fas, SIGNAL("triggered()"), on_lookup_forvo_selection)
def showContextMenu(self):
opts = [
[_("Mark Note"), "*", self.onMark],
[_("Bury Note"), "-", self.onBuryNote],
[_("Suspend Card"), "@", self.onSuspendCard],
[_("Suspend Note"), "!", self.onSuspend],
[_("Delete Note"), "Delete", self.onDelete],
[_("Options"), "O", self.onOptions],
None,
[_("Replay Audio"), "R", self.replayAudio],
[_("Record Own Voice"), "Shift+V", self.onRecordVoice],
[_("Replay Own Voice"), "V", self.onReplayRecorded],
]
m = QMenu(self.mw)
for row in opts:
if not row:
m.addSeparator()
continue
label, scut, func = row
a = m.addAction(label)
a.setShortcut(QKeySequence(scut))
a.connect(a, SIGNAL("triggered()"), func)
#Only change is the following statement
runHook("Reviewer.contextMenuEvent", self, m)
m.exec_(QCursor.pos())
def add_menu_items(menu_items, parent=None):
if not parent:
parent = mw.form.menubar
for title, action in menu_items:
if title == "SEPARATOR":
parent.addSeparator()
elif isinstance(action, list):
menu = QMenu(_(title), parent)
parent.insertMenu(mw.form.menuTools.menuAction(), menu)
add_menu_items(action, menu)
else:
checkable = False
if isinstance(action, dict):
options = action
action = options['action']
if 'checkable' in options:
checkable = options['checkable']
# if ANKNOTES.DEVELOPER_MODE.ENABLED and ANKNOTES.DEVELOPER_MODE.AUTO_RELOAD_MODULES:
action = auto_reload_wrapper(action)
# noinspection PyArgumentList
menu_action = QAction(_(title), mw, checkable=checkable)
parent.addAction(menu_action)
parent.connect(menu_action, SIGNAL("triggered()"), action)
if checkable:
anknotes_checkable_menu_items[title] = menu_action
def create_item(prefix, root, name, fs):
if name == '--':
root.addSeparator()
else:
action = QAction(name, mw)
mw.connect(action, SIGNAL("triggered()"), fs[prefix + '_' + to_id(name)])
root.addAction(action)
def more_less_button(self):
bb = self.form.buttonBox
ar = QDialogButtonBox.ActionRole
self.more_less_button = bb.addButton(_("Show less"), ar)
self.connect(self.more_less_button,
SIGNAL("clicked()"),
lambda add_dialog=self: show_more_less(add_dialog))
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
class BuildDBController(object):
def __init__(self, view, notifier, dbbuilder, compulsory):
# Reflect the initial setting values into the controls
view.controls.explanationLabel.setText(compulsory and firstrunmessage
or updateddatabasemessage)
view.controls.cancelButtonBox.setEnabled(not (compulsory))
# Create and run a thread that just constructs the database
class Worker(QThread):
def run(self):
try:
dbbuilder.build()
self.emit(SIGNAL("buildsuccess()"))
except Exception, e:
log.exception(
"Suppressed exception in database build process")
self.emit(SIGNAL("buildfailure(PyQt_PyObject)"),
sys.exc_info())
# NB: there is an EXTREMELY NASTY garbage collection bug lurking here. We need to
# ensure that the QThread is not garbage collected or else we will get a segmentation
# fault. This means that we must assign the thread as a member of self and make sure
# that the BuildDBController is saved somewhere by >it's< user! Apparently this is
# normal: <http://www.nabble.com/-python-Qt4-a-problem-of-QThread-td16993255.html>
self.thread = Worker()
def buildFailure(e):
notifier.exception(
"There was an error while building the Pinyin Toolkit database!",
e)
view.done(QDialog.Rejected)
view.connect(self.thread, SIGNAL("buildsuccess()"),
lambda: view.done(QDialog.Accepted))
view.connect(self.thread, SIGNAL("buildfailure(PyQt_PyObject)"),
lambda e: buildFailure(e))
# GO!
self.thread.start()
def setup_menu(browser):
a = QAction("Sync readings Audio", browser)
browser.form.menuEdit.addAction(a)
browser.connect(a, SIGNAL("triggered()"), run)
def duplicatesReportWrap(self, web, fname, search, frm):
res = self.mw.col.findDupes(fname, search)
if not self._dupesButton2:
self._dupesButton2 = b2 = frm.buttonBox.addButton(
_("Merge Duplicates"), QDialogButtonBox.ActionRole)
self.connect(b2, SIGNAL("clicked()"), lambda: mergeDupes(res))
def newNote(self, deckName, modelName, fields):
self.emit(SIGNAL("event"), 'newNote', deckName, modelName, fields)
def __init__(self, queue, ank):
self.queue = queue
self.connect(queue, SIGNAL("event"), self.onEvent)
self.ank = ank
path = getFile(mw, "Org file to import", cb=None, dir=expanduser("~"))
if not path:
return
with open(path, 'r') as f:
content = f.read().decode('utf-8')
entries = json.loads(content)
import itertools
get_deck = lambda e: e['deck']
entries = sorted(entries, key=get_deck)
mw.checkpoint(_("Import"))
logs = []
for deck_name, entries in itertools.groupby(entries, get_deck):
# FIXME: If required we could group by model name also!
importer = JsonImporter(mw.col, path, MODEL_NAME, deck_name)
importer.initMapping()
importer.run(list(entries))
if importer.log:
logs.append('\n'.join(importer.log))
txt = _("Importing complete.") + "\n"
txt += '\n'.join(logs)
showText(txt)
mw.reset()
action = QAction("Import from &JSON", mw)
mw.connect(action, SIGNAL("triggered()"), import_from_json)
mw.form.menuTools.addAction(action)
def _regMenu(function, title=title, menu=menu):
if not title: title = function.__name__
action = QAction(title, mw)
mw.connect(action, SIGNAL("triggered()"), function)
menu.addAction(action)
from settings import BeeminderSettings
from sync import syncDispatch
from anki.hooks import addHook
from aqt import mw
from aqt.qt import QAction, SIGNAL
# settings menu item
# ------------------
dialog = None
def openBeeminderSettings():
global dialog
if dialog is None:
dialog = BeeminderSettings()
dialog.display(mw)
openSettings = QAction("Setup Beeminder sync...", mw)
mw.connect(openSettings, SIGNAL("triggered()"), openBeeminderSettings)
mw.form.menuTools.addAction(openSettings)
# manual sync menu item
# ---------------------
manualSync = QAction("Sync with Beeminder", mw)
mw.connect(manualSync, SIGNAL("triggered()"), lambda: syncDispatch(at='manual'))
mw.form.menuTools.addAction(manualSync)
# sync at shutdown hook
# ---------------------
addHook("unloadProfile", lambda: syncDispatch(at='shutdown'))
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")