langfingaz/anki
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
a403b957cc
anki/qt/aqt/addcards.py

319 lines
12 KiB
Python
Raw Normal View History

update copyright and clarify licenses
2019-02-05 04:59:03 +01:00
# Copyright: Ankitects Pty Ltd and contributors
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
run pyupgrade over codebase [python upgrade required] This adds Python 3.9 and 3.10 typing syntax to files that import attributions from __future___. Python 3.9 should be able to cope with the 3.10 syntax, but Python 3.8 will no longer work. On Windows/Mac, install the latest Python 3.9 version from python.org. There are currently no orjson wheels for Python 3.10 on Windows/Mac, which will break the build unless you have Rust installed separately. On Linux, modern distros should have Python 3.9 available already. If you're on an older distro, you'll need to build Python from source first.
2021-10-03 10:59:42 +02:00
from typing import Callable, Optional
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
use isort to tidy up imports
2019-12-20 10:19:03 +01:00
import aqt.editor
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
import aqt.forms
avoid spurious warning in addcards startup
2021-08-20 03:37:23 +02:00
from anki._legacy import deprecated
undoable ops now return changes directly; add new *_ops.py files - Introduced a new transact() method that wraps the return value in a separate struct that describes the changes that were made. - Changes are now gathered from the undo log, so we don't need to guess at what was changed - eg if update_note() is called with identical note contents, no changes are returned. Card changes will only be set if cards were actually generated by the update_note() call, and tag will only be set if a new tag was added. - mw.perform_op() has been updated to expect the op to return the changes, or a structure with the changes in it, and it will use them to fire the change hook, instead of fetching the changes from undo_status(), so there is no risk of race conditions. - the various calls to mw.perform_op() have been split into separate files like card_ops.py. Aside from making the code cleaner, this works around a rather annoying issue with mypy. Because we run it with no_strict_optional, mypy is happy to accept an operation that returns None, despite the type signature saying it requires changes to be returned. Turning no_strict_optional on for the whole codebase is not practical at the moment, but we can enable it for individual files. Still todo: - The cursor keeps moving back to the start of a field when typing - we need to ignore the refresh hook when we are the initiator. - The busy cursor icon should probably be delayed a few hundreds ms. - Still need to think about a nicer way of handling saveNow() - op_made_changes(), op_affects_study_queue() might be better embedded as properties in the object instead
2021-03-16 05:26:42 +01:00
from anki.collection import OpChanges, SearchNode
ID -> Id in protobuf and Python follow-up to dc81a7fed07261e90672383ed147960065fc40a1
2021-03-27 12:38:20 +01:00
from anki.decks import DeckId
switch NoteType to Notetype When used as a variable, we were typically calling it a 'notetype', not a 'note type'.
2021-03-27 13:03:19 +01:00
from anki.models import NotetypeId
Check for out-of-place/missing clozes when adding
2021-06-12 10:05:42 +02:00
from anki.notes import Note, NoteFieldsCheckResult, NoteId
tidy up unused imports
2019-03-04 08:25:19 +01:00
from anki.utils import htmlToTextLine, isMac
migrate most of the remaining runHook() calls
2020-01-15 03:46:53 +01:00
from aqt import AnkiQt, gui_hooks
Add AddCards.deckChooser property for legacy access
2021-04-15 18:18:25 +02:00
from aqt.deckchooser import DeckChooser
switch NoteType to Notetype When used as a variable, we were typically calling it a 'notetype', not a 'note type'.
2021-03-27 13:03:19 +01:00
from aqt.notetypechooser import NotetypeChooser
move operations into submodule
2021-04-03 08:26:10 +02:00
from aqt.operations.note import add_note
use isort to tidy up imports
2019-12-20 10:19:03 +01:00
from aqt.qt import *
update qt/ to use the new API
2020-01-20 11:10:38 +01:00
from aqt.sound import av_player
apply black to all files
2019-12-23 01:34:10 +01:00
from aqt.utils import (
NF: HelpPage in an enum Hopefully, this can help with updating on next manual update and maybe even linking to manual translation
2021-01-25 14:45:47 +01:00
HelpPage,
apply black to all files
2019-12-23 01:34:10 +01:00
addCloseShortcut,
askUser,
convert setWindowFlags call into helper, and fix invalid variables "type: ignore" was masking the invalid references to self in places like showText()
2021-01-07 05:24:49 +01:00
disable_help_button,
apply black to all files
2019-12-23 01:34:10 +01:00
downArrow,
openHelp,
restoreGeom,
saveGeom,
shortcut,
showWarning,
tooltip,
merge bulk of qt/ - designer files still to do
2020-11-17 08:42:43 +01:00
tr,
apply black to all files
2019-12-23 01:34:10 +01:00
)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
add some typing to addcards and main
2019-12-20 09:43:52 +01:00
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
class AddCards(QDialog):
add some typing to addcards and main
2019-12-20 09:43:52 +01:00
def __init__(self, mw: AnkiQt) -> None:
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
QDialog.__init__(self, None, Qt.Window)
commit immediately when there's no active checkpoint Reviews and operations on the backend that support undoing can now be committed immediately, so they will not be lost in the event of a crash. This required tweaks to a few places: - don't set collection mtime on save() unless changes were made in Python, as otherwise we end up accidentally clearing the backend undo queue - autosave() is now run on every reset() - garbage collection now runs in a timer, instead of relying on autosave() to be run periodically
2021-03-05 04:07:52 +01:00
mw.garbage_collect_on_dialog_finish(self)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.mw = mw
squash merge browser refactor Closes #1100
2021-03-29 08:12:26 +02:00
self.col = mw.col
avoid spurious warning in addcards startup
2021-08-20 03:37:23 +02:00
form = aqt.forms.addcards.Ui_Dialog()
form.setupUi(self)
self.form = form
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
self.setWindowTitle(tr.actions_add())
convert setWindowFlags call into helper, and fix invalid variables "type: ignore" was masking the invalid references to self in places like showText()
2021-01-07 05:24:49 +01:00
disable_help_button(self)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.setMinimumHeight(300)
self.setMinimumWidth(400)
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
self.setup_choosers()
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.setupEditor()
self.setupButtons()
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
self._load_new_note()
run pyupgrade over codebase [python upgrade required] This adds Python 3.9 and 3.10 typing syntax to files that import attributions from __future___. Python 3.9 should be able to cope with the 3.10 syntax, but Python 3.8 will no longer work. On Windows/Mac, install the latest Python 3.9 version from python.org. There are currently no orjson wheels for Python 3.10 on Windows/Mac, which will break the build unless you have Rust installed separately. On Linux, modern distros should have Python 3.9 available already. If you're on an older distro, you'll need to build Python from source first.
2021-10-03 10:59:42 +02:00
self.history: list[NoteId] = []
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
self._last_added_note: Optional[Note] = None
undoing of notetype fields - fix stale cache issue - update add cards screen in response to op changes
2021-04-30 09:15:59 +02:00
gui_hooks.operation_did_execute.append(self.on_operation_did_execute)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
restoreGeom(self, "add")
add cmd+w shortcut to add cards window & stats window
2012-12-22 01:11:29 +01:00
addCloseShortcut(self)
hook add_card_did_init
2020-04-03 10:54:54 +02:00
gui_hooks.add_cards_did_init(self)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.show()
add some typing to addcards and main
2019-12-20 09:43:52 +01:00
def setupEditor(self) -> None:
apply black to all files
2019-12-23 01:34:10 +01:00
self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea, self, True)
Add toggle sticky shortcuts F9 and Shift+F9
2021-08-03 05:52:07 +02:00
self.editor.web.eval("activateStickyShortcuts();")
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
def setup_choosers(self) -> None:
squash merge browser refactor Closes #1100
2021-03-29 08:12:26 +02:00
defaults = self.col.defaults_for_adding(
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
current_review_card=self.mw.reviewer.card
)
switch NoteType to Notetype When used as a variable, we were typically calling it a 'notetype', not a 'note type'.
2021-03-27 13:03:19 +01:00
self.notetype_chooser = NotetypeChooser(
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
mw=self.mw,
widget=self.form.modelArea,
switch NoteType to Notetype When used as a variable, we were typically calling it a 'notetype', not a 'note type'.
2021-03-27 13:03:19 +01:00
starting_notetype_id=NotetypeId(defaults.notetype_id),
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
on_button_activated=self.show_notetype_selector,
on_notetype_changed=self.on_notetype_change,
)
Add AddCards.deckChooser property for legacy access
2021-04-15 18:18:25 +02:00
self.deck_chooser = DeckChooser(
ID -> Id in protobuf and Python follow-up to dc81a7fed07261e90672383ed147960065fc40a1
2021-03-27 12:38:20 +01:00
self.mw, self.form.deckArea, starting_deck_id=DeckId(defaults.deck_id)
fix IndexError when switching notetypes Closes #780 https://github.com/ankitects/anki/pull/780
2020-10-05 05:33:54 +02:00
)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
add a bunch of return types
2021-02-01 14:28:21 +01:00
def helpRequested(self) -> None:
NF: HelpPage in an enum Hopefully, this can help with updating on next manual update and maybe even linking to manual translation
2021-01-25 14:45:47 +01:00
openHelp(HelpPage.ADDING_CARD_AND_NOTE)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
add some typing to addcards and main
2019-12-20 09:43:52 +01:00
def setupButtons(self) -> None:
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
bb = self.form.buttonBox
ar = QDialogButtonBox.ActionRole
# add
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
self.addButton = bb.addButton(tr.actions_add(), ar)
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
qconnect(self.addButton.clicked, self.add_current_note)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.addButton.setShortcut(QKeySequence("Ctrl+Return"))
handle ctrl+numpad enter on Windows https://forums.ankiweb.net/t/ctrl-enter-with-the-number-pad-doesnt-work/10323/5
2021-06-01 08:25:12 +02:00
# qt5.14 doesn't handle numpad enter on Windows
self.compat_add_shorcut = QShortcut(QKeySequence("Ctrl+Enter"), self)
qconnect(self.compat_add_shorcut.activated, self.addButton.click)
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
self.addButton.setToolTip(shortcut(tr.adding_add_shortcut_ctrlandenter()))
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
# close
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
self.closeButton = QPushButton(tr.actions_close())
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.closeButton.setAutoDefault(False)
port majority of code to qt5.5+ - a few issues to work out still, and editor changes not done yet - for communication between webengine and python code, we set window .location to 'http://anki/<something>' - the leading http is necessary for qt to call the link handler, which was introduced in qt5.5 - the designer files now use a promoted qobject to create instances of AnkiWebView - we use the css zoom property to alter webengine font size based on system dpi - prefs and addons folder stored in new location (at least for now)
2016-05-31 10:51:40 +02:00
bb.addButton(self.closeButton, QDialogButtonBox.RejectRole)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
# help
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
self.helpButton = QPushButton(tr.actions_help(), clicked=self.helpRequested) # type: ignore
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.helpButton.setAutoDefault(False)
apply black to all files
2019-12-23 01:34:10 +01:00
bb.addButton(self.helpButton, QDialogButtonBox.HelpRole)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
# history
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
b = bb.addButton(f"{tr.adding_history()} {downArrow()}", ar)
shortcut key for history button
2013-05-23 07:44:00 +02:00
if isMac:
sc = "Ctrl+Shift+H"
else:
sc = "Ctrl+H"
b.setShortcut(QKeySequence(sc))
update TR references that contain arguments
2021-03-26 05:21:04 +01:00
b.setToolTip(tr.adding_shortcut(val=shortcut(sc)))
use qconnect everywhere, and fix some typing issues a step towards check_untyped_defs in aqt, but there's still 100+ issues to resolve
2020-05-04 05:23:08 +02:00
qconnect(b.clicked, self.onHistory)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
b.setEnabled(False)
self.historyButton = b
add some typing to addcards and main
2019-12-20 09:43:52 +01:00
def setAndFocusNote(self, note: Note) -> None:
prevent editor from refreshing itself after a save - add after_hooks arg to perform_op() - when refreshing browse screen, just redraws cells, and handle editor update in Browser instead of the model
2021-03-16 07:39:41 +01:00
self.editor.set_note(note, focusTo=0)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
fix IndexError when switching notetypes Closes #780 https://github.com/ankitects/anki/pull/780
2020-10-05 05:33:54 +02:00
def show_notetype_selector(self) -> None:
decorator for saveNow(), mkII Mostly @RumovZ's work from https://github.com/ankitects/anki/pull/1066, with a workaround for the issue encountered on https://github.com/ankitects/anki/commit/6e0e17b2b9c28405db9f8644e0d445a662f84b13 Fix is to use pyqtSlot() to specify the slot signature, as described on https://stackoverflow.com/questions/44371451/python-pyqt-qt-qmenu-qaction-syntax Also renamed saveNow() for PEP8, but have not updated all the existing calls to use the decorator yet - might be easiest to do at the same time as perform_op() calls are added.
2021-03-16 13:40:37 +01:00
self.editor.call_after_note_saved(self.notetype_chooser.choose_notetype)
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
switch NoteType to Notetype When used as a variable, we were typically calling it a 'notetype', not a 'note type'.
2021-03-27 13:03:19 +01:00
def on_notetype_change(self, notetype_id: NotetypeId) -> None:
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
# need to adjust current deck?
squash merge browser refactor Closes #1100
2021-03-29 08:12:26 +02:00
if deck_id := self.col.default_deck_for_notetype(notetype_id):
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
self.deck_chooser.selected_deck_id = deck_id
# only used for detecting changed sticky fields on close
self._last_added_note = None
# copy fields into new note with the new notetype
old = self.editor.note
new = self._new_note()
if old:
old_fields = list(old.keys())
new_fields = list(new.keys())
PEP8 cards.py
2021-06-27 04:12:23 +02:00
for n, f in enumerate(new.note_type()["flds"]):
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
field_name = f["name"]
Preserve identical fields when switching note types
2016-04-10 13:11:25 +02:00
# copy identical fields
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
if field_name in old_fields:
new[field_name] = old[field_name]
PEP8 cards.py
2021-06-27 04:12:23 +02:00
elif n < len(old.note_type()["flds"]):
single try in onModelChange
2020-04-26 16:52:35 +02:00
# set non-identical fields by field index
PEP8 cards.py
2021-06-27 04:12:23 +02:00
old_field_name = old.note_type()["flds"][n]["name"]
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
if old_field_name not in new_fields:
new.fields[n] = old.fields[n]
fix pin toggle causing saved tags to get lost
2021-06-24 12:16:21 +02:00
new.tags = old.tags
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
# and update editor state
self.editor.note = new
preserve focus on notetype change Closes #1360
2021-09-13 07:31:24 +02:00
self.editor.loadNote(
focusTo=min(self.editor.last_field_index or 0, len(new.fields) - 1)
)
Add hook after selecting a new note type in the add window
2021-09-25 04:22:42 +02:00
gui_hooks.add_cards_did_change_note_type(old.note_type(), new.note_type())
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
def _load_new_note(self, sticky_fields_from: Optional[Note] = None) -> None:
note = self._new_note()
if old_note := sticky_fields_from:
PEP8 cards.py
2021-06-27 04:12:23 +02:00
flds = note.note_type()["flds"]
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
# copy fields from old note
if old_note:
for n in range(min(len(note.fields), len(old_note.fields))):
if flds[n]["sticky"]:
note.fields[n] = old_note.fields[n]
fix remembered tags not being applied to next added note https://forums.ankiweb.net/t/anki-2-1-45-alpha/10061/56
2021-05-27 05:18:34 +02:00
# and tags
note.tags = old_note.tags
refactor editor focus handling this fixes a bug where navigating to the next/previous card using shortcut keys resulted in the first field being clobbered - get rid of the stealFocus option in favour of explicitly passing focusTo to setNote() - setFields() is no longer responsible for setting focus - add focusTo var to the browser so that the row changed hook can restore focus when navigating to next/previous card - fix the row changed hook being called twice - the blur event now includes the field number instead of relying on the editor to have the correct currentField - the current field is set to null on blur - use deferred js and a callback rather than keeping track of when we were loaded - add shift+tab shortcut to go to previous field
2017-08-05 07:15:19 +02:00
self.setAndFocusNote(note)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
undoing of notetype fields - fix stale cache issue - update add cards screen in response to op changes
2021-04-30 09:15:59 +02:00
def on_operation_did_execute(
self, changes: OpChanges, handler: Optional[object]
) -> None:
if (changes.notetype or changes.deck) and handler is not self.editor:
self.on_notetype_change(
NotetypeId(
self.col.defaults_for_adding(
current_review_card=self.mw.reviewer.card
).notetype_id
)
)
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
def _new_note(self) -> Note:
squash merge browser refactor Closes #1100
2021-03-29 08:12:26 +02:00
return self.col.new_note(
self.col.models.get(self.notetype_chooser.selected_notetype_id)
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
add types to various other files Mainly automated with MonkeyType
2021-02-01 13:08:56 +01:00
def addHistory(self, note: Note) -> None:
Show latest data under History in the Add dialog
2017-01-08 14:48:58 +01:00
self.history.insert(0, note.id)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.history = self.history[:15]
self.historyButton.setEnabled(True)
add qconnect helper and some type hints The type hints allow mypy to check the gui_hook calls, revealing a bunch of places that are broken as they expect no arguments like the legacy hooks. To make mypy happy about PyQt's signal.connect(func), a qconnect() helper has been added.
2020-01-15 22:41:23 +01:00
def onHistory(self) -> None:
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
m = QMenu(self)
Show latest data under History in the Add dialog
2017-01-08 14:48:58 +01:00
for nid in self.history:
squash merge browser refactor Closes #1100
2021-03-29 08:12:26 +02:00
if self.col.find_notes(self.col.build_search_string(SearchNode(nid=nid))):
note = self.col.get_note(nid)
hook: history_line I expect to use this hook to create an add-on which will simply remove the ",,". By ignoring empty fields I expect to make this easier to use.
2020-06-03 23:29:09 +02:00
fields = note.fields
use a clearer name for fmtQA()
2017-03-14 07:48:40 +01:00
txt = htmlToTextLine(", ".join(fields))
Insert ellipsis in history string
2017-02-05 08:45:08 +01:00
if len(txt) > 30:
convert qt strings to f-strings with flynt Also revealed an incorrect type def in editor.py that mypy wasn't noticing before :-(
2021-02-11 01:09:06 +01:00
txt = f"{txt[:30]}..."
update TR references that contain arguments
2021-03-26 05:21:04 +01:00
line = tr.adding_edit(val=txt)
hook: history_line I expect to use this hook to create an add-on which will simply remove the ",,". By ignoring empty fields I expect to make this easier to use.
2020-06-03 23:29:09 +02:00
line = gui_hooks.addcards_will_add_history_entry(line, note)
Add Card history: keep & instead of replacing them by underline
2021-08-15 06:32:03 +02:00
line = line.replace("&", "&&")
# In qt action "&i" means "underline i, trigger this line when i is pressed".
# except for "&&" which is replaced by a single "&"
hook: history_line I expect to use this hook to create an add-on which will simply remove the ",,". By ignoring empty fields I expect to make this easier to use.
2020-06-03 23:29:09 +02:00
a = m.addAction(line)
add qconnect helper and some type hints The type hints allow mypy to check the gui_hook calls, revealing a bunch of places that are broken as they expect no arguments like the legacy hooks. To make mypy happy about PyQt's signal.connect(func), a qconnect() helper has been added.
2020-01-15 22:41:23 +01:00
qconnect(a.triggered, lambda b, nid=nid: self.editHistory(nid))
Fix bug caused when deleting a card just added and clicking History
2017-01-09 11:55:30 +01:00
else:
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
a = m.addAction(tr.adding_note_deleted())
Fix bug caused when deleting a card just added and clicking History
2017-01-09 11:55:30 +01:00
a.setEnabled(False)
more tweaks for readability/consistency
2020-01-15 08:45:35 +01:00
gui_hooks.add_cards_will_show_history_menu(self, m)
.exec_() -> .exec() The former is not supported in PyQt6
2021-10-05 02:01:45 +02:00
m.exec(self.historyButton.mapToGlobal(QPoint(0, 0)))
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
ID -> Id in protobuf and Python follow-up to dc81a7fed07261e90672383ed147960065fc40a1
2021-03-27 12:38:20 +01:00
def editHistory(self, nid: NoteId) -> None:
tweak search wording and tidy up API - SearchTerm -> SearchNode - Operator -> Joiner; share between messages - build_search_string() supports specifying AND/OR as a convenience - group_searches() makes it easier to negate
2021-02-11 10:57:19 +01:00
aqt.dialogs.open("Browser", self.mw, search=(SearchNode(nid=nid),))
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
def add_current_note(self) -> None:
decorator for saveNow(), mkII Mostly @RumovZ's work from https://github.com/ankitects/anki/pull/1066, with a workaround for the issue encountered on https://github.com/ankitects/anki/commit/6e0e17b2b9c28405db9f8644e0d445a662f84b13 Fix is to use pyqtSlot() to specify the slot signature, as described on https://stackoverflow.com/questions/44371451/python-pyqt-qt-qmenu-qaction-syntax Also renamed saveNow() for PEP8, but have not updated all the existing calls to use the decorator yet - might be easiest to do at the same time as perform_op() calls are added.
2021-03-16 13:40:37 +01:00
self.editor.call_after_note_saved(self._add_current_note)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
def _add_current_note(self) -> None:
note = self.editor.note
saveNow() now requires a callback the current code was freezing when clicking on 'cards' in the browser - it looks like like the javascript callback was never being called despite calling processEvents(). so we need to refactor the code to call saveNow() with a callback that does the subsequent processing. a lot of the browser code was implicitly calling saveNow() via beginReset(), so we've had to change all that code to save immediately before it begins any processing. found a probable bug in the process - it doesn't look like onRowChange() was saving before overwriting the note, so theoretically edits could be lost if the user switched to another card very quickly after typing something. onSearch() has been split into a GUI-activated onSearchActivated() that takes care of saving, and a lower level search() that refreshes the current search. it keeps track of the last search via an instance variable so that it refreshes properly if a user accidentally adds some characters to their search without activating the search, then does something like reverse the sort order.
2016-07-14 12:23:44 +02:00
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
if not self._note_can_be_added(note):
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
return
Work around Qt's focus bug (fix help-wanted#22) Manually hide the editor's completer popup before accepting a short cut which changes the focus widget. Thus, work around the bug in PyQt 5.15 where a QLineEdit with open QCompleter popup won't get notified about focus changes handled by the Main Window, leading to inconsistent focus.
2020-10-24 10:47:25 +02:00
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
target_deck_id = self.deck_chooser.selected_deck_id
undoable ops now return changes directly; add new *_ops.py files - Introduced a new transact() method that wraps the return value in a separate struct that describes the changes that were made. - Changes are now gathered from the undo log, so we don't need to guess at what was changed - eg if update_note() is called with identical note contents, no changes are returned. Card changes will only be set if cards were actually generated by the update_note() call, and tag will only be set if a new tag was added. - mw.perform_op() has been updated to expect the op to return the changes, or a structure with the changes in it, and it will use them to fire the change hook, instead of fetching the changes from undo_status(), so there is no risk of race conditions. - the various calls to mw.perform_op() have been split into separate files like card_ops.py. Aside from making the code cleaner, this works around a rather annoying issue with mypy. Because we run it with no_strict_optional, mypy is happy to accept an operation that returns None, despite the type signature saying it requires changes to be returned. Turning no_strict_optional on for the whole codebase is not practical at the moment, but we can enable it for individual files. Still todo: - The cursor keeps moving back to the start of a field when typing - we need to ignore the refresh hook when we are the initiator. - The busy cursor icon should probably be delayed a few hundreds ms. - Still need to think about a nicer way of handling saveNow() - op_made_changes(), op_affects_study_queue() might be better embedded as properties in the object instead
2021-03-16 05:26:42 +01:00
def on_success(changes: OpChanges) -> None:
# only used for detecting changed sticky fields on close
self._last_added_note = note
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
undoable ops now return changes directly; add new *_ops.py files - Introduced a new transact() method that wraps the return value in a separate struct that describes the changes that were made. - Changes are now gathered from the undo log, so we don't need to guess at what was changed - eg if update_note() is called with identical note contents, no changes are returned. Card changes will only be set if cards were actually generated by the update_note() call, and tag will only be set if a new tag was added. - mw.perform_op() has been updated to expect the op to return the changes, or a structure with the changes in it, and it will use them to fire the change hook, instead of fetching the changes from undo_status(), so there is no risk of race conditions. - the various calls to mw.perform_op() have been split into separate files like card_ops.py. Aside from making the code cleaner, this works around a rather annoying issue with mypy. Because we run it with no_strict_optional, mypy is happy to accept an operation that returns None, despite the type signature saying it requires changes to be returned. Turning no_strict_optional on for the whole codebase is not practical at the moment, but we can enable it for individual files. Still todo: - The cursor keeps moving back to the start of a field when typing - we need to ignore the refresh hook when we are the initiator. - The busy cursor icon should probably be delayed a few hundreds ms. - Still need to think about a nicer way of handling saveNow() - op_made_changes(), op_affects_study_queue() might be better embedded as properties in the object instead
2021-03-16 05:26:42 +01:00
self.addHistory(note)
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
tooltip(tr.adding_added(), period=500)
undoable ops now return changes directly; add new *_ops.py files - Introduced a new transact() method that wraps the return value in a separate struct that describes the changes that were made. - Changes are now gathered from the undo log, so we don't need to guess at what was changed - eg if update_note() is called with identical note contents, no changes are returned. Card changes will only be set if cards were actually generated by the update_note() call, and tag will only be set if a new tag was added. - mw.perform_op() has been updated to expect the op to return the changes, or a structure with the changes in it, and it will use them to fire the change hook, instead of fetching the changes from undo_status(), so there is no risk of race conditions. - the various calls to mw.perform_op() have been split into separate files like card_ops.py. Aside from making the code cleaner, this works around a rather annoying issue with mypy. Because we run it with no_strict_optional, mypy is happy to accept an operation that returns None, despite the type signature saying it requires changes to be returned. Turning no_strict_optional on for the whole codebase is not practical at the moment, but we can enable it for individual files. Still todo: - The cursor keeps moving back to the start of a field when typing - we need to ignore the refresh hook when we are the initiator. - The busy cursor icon should probably be delayed a few hundreds ms. - Still need to think about a nicer way of handling saveNow() - op_made_changes(), op_affects_study_queue() might be better embedded as properties in the object instead
2021-03-16 05:26:42 +01:00
av_player.stop_and_clear_queue()
self._load_new_note(sticky_fields_from=note)
gui_hooks.add_cards_did_add_note(note)
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
update note ops remove_note() now returns the count of removed cards, allowing us to unify the tooltip between browser and review screen I've left the old translation in - we'll need to write a script at one point that gathers all references to translations in the code, and shows ones that are unused.
2021-04-06 06:56:36 +02:00
add_note(parent=self, note=note, target_deck_id=target_deck_id).success(
on_success
).run_in_background()
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
def _note_can_be_added(self, note: Note) -> bool:
Check for out-of-place/missing clozes when adding
2021-06-12 10:05:42 +02:00
result = note.fields_check()
fix error when user confirms adding cloze to basic type
2021-06-26 00:35:24 +02:00
# no problem, duplicate, and confirmed cloze cases
problem = None
Check for out-of-place/missing clozes when adding
2021-06-12 10:05:42 +02:00
if result == NoteFieldsCheckResult.EMPTY:
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
problem = tr.adding_the_first_field_is_empty()
Check for out-of-place/missing clozes when adding
2021-06-12 10:05:42 +02:00
elif result == NoteFieldsCheckResult.MISSING_CLOZE:
Make missing cloze a warning again
2021-06-14 10:20:53 +02:00
if not askUser(tr.adding_you_have_a_cloze_deletion_note()):
return False
Check for out-of-place/missing clozes when adding
2021-06-12 10:05:42 +02:00
elif result == NoteFieldsCheckResult.NOTETYPE_NOT_CLOZE:
problem = tr.adding_cloze_outside_cloze_notetype()
elif result == NoteFieldsCheckResult.FIELD_NOT_CLOZE:
problem = tr.adding_cloze_outside_cloze_field()
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
# filter problem through add-ons
problem = gui_hooks.add_cards_will_add_note(problem, note)
if problem is not None:
showWarning(problem, help=HelpPage.ADDING_CARD_AND_NOTE)
return False
return True
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
add types to various other files Mainly automated with MonkeyType
2021-02-01 13:08:56 +01:00
def keyPressEvent(self, evt: QKeyEvent) -> None:
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
"Show answer on RET or register answer."
apply black to all files
2019-12-23 01:34:10 +01:00
if evt.key() in (Qt.Key_Enter, Qt.Key_Return) and self.editor.tags.hasFocus():
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
evt.accept()
return
return QDialog.keyPressEvent(self, evt)
add some typing to addcards and main
2019-12-20 09:43:52 +01:00
def reject(self) -> None:
use callback when closing windows remove the old forceClose hack in favour of a callback when closing, so all windows have a chance to save properly before the collection is unloaded also: - fix a warning shown when opening about screen - require a call to editor.cleanup() when closing a window, to make sure any pending js callbacks don't try to fire on a deleted object - make sure we gc webview when closing editcurrent - main.py still needs refactoring to make use of the change
2017-08-16 04:45:33 +02:00
self.ifCanClose(self._reject)
add some typing to addcards and main
2019-12-20 09:43:52 +01:00
def _reject(self) -> None:
update qt/ to use the new API
2020-01-20 11:10:38 +01:00
av_player.stop_and_clear_queue()
use callback when closing windows remove the old forceClose hack in favour of a callback when closing, so all windows have a chance to save properly before the collection is unloaded also: - fix a warning shown when opening about screen - require a call to editor.cleanup() when closing a window, to make sure any pending js callbacks don't try to fire on a deleted object - make sure we gc webview when closing editcurrent - main.py still needs refactoring to make use of the change
2017-08-16 04:45:33 +02:00
self.editor.cleanup()
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
self.notetype_chooser.cleanup()
undoing of notetype fields - fix stale cache issue - update add cards screen in response to op changes
2021-04-30 09:15:59 +02:00
gui_hooks.operation_did_execute.remove(self.on_operation_did_execute)
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
self.mw.maybeReset()
saveGeom(self, "add")
use callback when closing windows remove the old forceClose hack in favour of a callback when closing, so all windows have a chance to save properly before the collection is unloaded also: - fix a warning shown when opening about screen - require a call to editor.cleanup() when closing a window, to make sure any pending js callbacks don't try to fire on a deleted object - make sure we gc webview when closing editcurrent - main.py still needs refactoring to make use of the change
2017-08-16 04:45:33 +02:00
aqt.dialogs.markClosed("AddCards")
merged libanki and ankiqt into single distro
2012-12-21 08:51:59 +01:00
QDialog.reject(self)
add some typing to addcards and main
2019-12-20 09:43:52 +01:00
def ifCanClose(self, onOk: Callable) -> None:
add a bunch of return types
2021-02-01 14:28:21 +01:00
def afterSave() -> None:
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
ok = self.editor.fieldsAreBlank(self._last_added_note) or askUser(
update no-arg tr references in qt/
2021-03-26 04:48:26 +01:00
tr.adding_close_and_lose_current_input(), defaultno=True
apply black to all files
2019-12-23 01:34:10 +01:00
)
use callback when closing windows remove the old forceClose hack in favour of a callback when closing, so all windows have a chance to save properly before the collection is unloaded also: - fix a warning shown when opening about screen - require a call to editor.cleanup() when closing a window, to make sure any pending js callbacks don't try to fire on a deleted object - make sure we gc webview when closing editcurrent - main.py still needs refactoring to make use of the change
2017-08-16 04:45:33 +02:00
if ok:
onOk()
decorator for saveNow(), mkII Mostly @RumovZ's work from https://github.com/ankitects/anki/pull/1066, with a workaround for the issue encountered on https://github.com/ankitects/anki/commit/6e0e17b2b9c28405db9f8644e0d445a662f84b13 Fix is to use pyqtSlot() to specify the slot signature, as described on https://stackoverflow.com/questions/44371451/python-pyqt-qt-qmenu-qaction-syntax Also renamed saveNow() for PEP8, but have not updated all the existing calls to use the decorator yet - might be easiest to do at the same time as perform_op() calls are added.
2021-03-16 13:40:37 +01:00
self.editor.call_after_note_saved(afterSave)
use callback when closing windows remove the old forceClose hack in favour of a callback when closing, so all windows have a chance to save properly before the collection is unloaded also: - fix a warning shown when opening about screen - require a call to editor.cleanup() when closing a window, to make sure any pending js callbacks don't try to fire on a deleted object - make sure we gc webview when closing editcurrent - main.py still needs refactoring to make use of the change
2017-08-16 04:45:33 +02:00
add remaining types and disable missing types on (almost) all aqt
2021-02-02 15:00:29 +01:00
def closeWithCallback(self, cb: Callable[[], None]) -> None:
add a bunch of return types
2021-02-01 14:28:21 +01:00
def doClose() -> None:
use callback when closing windows remove the old forceClose hack in favour of a callback when closing, so all windows have a chance to save properly before the collection is unloaded also: - fix a warning shown when opening about screen - require a call to editor.cleanup() when closing a window, to make sure any pending js callbacks don't try to fire on a deleted object - make sure we gc webview when closing editcurrent - main.py still needs refactoring to make use of the change
2017-08-16 04:45:33 +02:00
self._reject()
cb()
apply black to all files
2019-12-23 01:34:10 +01:00
use callback when closing windows remove the old forceClose hack in favour of a callback when closing, so all windows have a chance to save properly before the collection is unloaded also: - fix a warning shown when opening about screen - require a call to editor.cleanup() when closing a window, to make sure any pending js callbacks don't try to fire on a deleted object - make sure we gc webview when closing editcurrent - main.py still needs refactoring to make use of the change
2017-08-16 04:45:33 +02:00
self.ifCanClose(doClose)
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
# legacy aliases
Add AddCards.deckChooser property for legacy access
2021-04-15 18:18:25 +02:00
@property
def deckChooser(self) -> DeckChooser:
avoid spurious warning in addcards startup
2021-08-20 03:37:23 +02:00
if getattr(self, "form", None):
# show this warning only after Qt form has been initialized,
# or PyQt's introspection triggers it
print("deckChooser is deprecated; use deck_chooser instead")
Add AddCards.deckChooser property for legacy access
2021-04-15 18:18:25 +02:00
return self.deck_chooser
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
addCards = add_current_note
_addCards = _add_current_note
onModelChange = on_notetype_change
avoid spurious warning in addcards startup
2021-08-20 03:37:23 +02:00
@deprecated(info="obsolete")
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
def addNote(self, note: Note) -> None:
avoid spurious warning in addcards startup
2021-08-20 03:37:23 +02:00
pass
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
avoid spurious warning in addcards startup
2021-08-20 03:37:23 +02:00
@deprecated(info="does nothing; will go away")
Simplify note adding and the deck/notetype choosers The existing code was really difficult to reason about: - The default notetype depended on the selected deck, and vice versa, and this logic was buried in the deck and notetype choosing screens, and models.py. - Changes to the notetype were not passed back directly, but were fired via a hook, which changed any screen in the app that had a notetype selector. It also wasn't great for performance, as the most recent deck and tags were embedded in the notetype, which can be expensive to save and sync for large notetypes. To address these points: - The current deck for a notetype, and notetype for a deck, are now stored in separate config variables, instead of directly in the deck or notetype. These are cheap to read and write, and we'll be able to sync them individually in the future once config syncing is updated in the future. I seem to recall some users not wanting the tag saving behaviour, so I've dropped that for now, but if people end up missing it, it would be simple to add as an extra auxiliary config variable. - The logic for getting the starting deck and notetype has been moved into the backend. It should be the same as the older Python code, with one exception: when "change deck depending on notetype" is enabled in the preferences, it will start with the current notetype ("curModel"), instead of first trying to get a deck-specific notetype. - ModelChooser has been duplicated into notetypechooser.py, and it has been updated to solely be concerned with keeping track of a selected notetype - it no longer alters global state.
2021-03-08 14:23:24 +01:00
def removeTempNote(self, note: Note) -> None:
avoid spurious warning in addcards startup
2021-08-20 03:37:23 +02:00
pass
Reference in New Issue Copy Permalink