def changeEnableToShowPattern(self, checked):
ConfigIni.getInstance().setShowPattern(checked)
if checked and hasattr(self, 'asking_canvas'):
self.asking_canvas.answer_field.showPattern()
elif hasattr(self, 'asking_canvas'):
self.asking_canvas.answer_field.hidePattern()
self.asking_canvas.answer_field.setFirstFocus()
def __init__(self, word, font=None, size=None, color=None, bg=None):
super().__init__()
self.word = word
# This field is the patter - just right under the input field - disabled - not focusable
self.patternField = SingleField(word,
parent=self,
font=font,
size=size,
color=type(self).PATTERN_COLOR,
bg=type(self).PATTERN_BG)
if ConfigIni.getInstance().isShowPattern():
self.showPattern()
self.patternField.setEnabled(False)
self.patternField.move(0, 0)
self.patternField.setFocusPolicy(Qt.NoFocus)
# Input field - Transparent - behind it the pattern is visible
self.textField = SingleField(word,
parent=self,
font=font,
size=size,
color=color,
bg=bg)
self.textField.move(0, 0)
self.textField.viewport().setAutoFillBackground(False)
self.setMinimumSize(self.textField.minimumSize())
def round(self, wrong_record=None):
"""
Frame of asking word.
The other part of hte round is in the OKButton's on_click() method
-calculates the the new word to ask
-fill up the POS field
-fill up the QUESTION field
-fill up the ANSWER field
-fill up the EXPECTED ANSWER field
-say out the question
-waiting for the user response
Input
wrong_record
- It is unrelevant until all words was answerd
- If it is EMPTY then the chance depends on the points
- If it is NOT EMPTY the the same question will be asked until it answered
"""
# hides the result lamp
self.result_lamp.set_result(None)
self.record = self.myFilteredDictionary.get_next_random_record(
wrong_record)
good_answer = self.record.learning_words
# pos field
self.pos_field.setText(self.record.part_of_speach)
# question
self.question_field.setText(self.record.base_word)
config_ini = ConfigIni.getInstance()
# note field
if config_ini.isShowNote():
self.note_field.setText(self.record.note)
# answer
self.answer_field.setExpectedWordList(good_answer)
self.answer_field.enableText()
# expected answer
self.good_answer_field.setExpectedWordList(good_answer)
# say out the question in a thread
if config_ini.isSayOut():
Thread(target=self.record.say_out_base, args=()).start()
self.answer_field.setFirstFocus()
# shows statistics
self.showStat()
def __init__(self, file_name, part_of_speech_filter="", extra_filter=""):
config_ini = ConfigIni.getInstance()
language = config_ini.getLanguage()
base_language = to_name(config_ini.getBaseLanguage()).lower()
learning_language = to_name(config_ini.getLearningLanguage()).lower()
self.say_out = config_ini.isSayOut(),
self.show_pattern = config_ini.isShowPattern(),
self.show_note = config_ini.isShowNote()
self.myFilteredDictionary = FilteredDictionary(file_name,
base_language,
learning_language,
part_of_speech_filter,
extra_filter)
def on_click(self):
if self.status == OKButton.STATUS.ACCEPT:
self.asking_object.answer_field.disableText()
# shows the difference between the the answer and the good answer -> tuple
# [0] -> False/True
# [1] -> list of list of thedisable positions of the difference in the words
self.result = self.asking_object.record.check_answer(
self.asking_object.answer_field.getFieldsContentList())
# write back the stat
self.asking_object.myFilteredDictionary.add_result_to_stat(
self.asking_object.record.word_id, self.result[0])
# show the result in green/red lamp
if self.result[0]:
self.asking_object.result_lamp.set_result(True)
else:
self.asking_object.result_lamp.set_result(False)
# shows the expected answer with differences
self.asking_object.good_answer_field.showText(
self.result[1],
self.asking_object.answer_field.getFieldsContentList())
# shows statistics
self.asking_object.showStat()
self.status = OKButton.STATUS.NEXT
# say out the right answer in thread
if ConfigIni.getInstance().isSayOut():
Thread(target=self.asking_object.record.say_out_learning,
args=()).start()
elif self.status == OKButton.STATUS.NEXT:
self.status = OKButton.STATUS.ACCEPT
# starts a new round
self.asking_object.round(
None if self.result[0] else self.asking_object.record)
# shows statistics
self.asking_object.showStat()
def __init__(self, status_bar, file_name, part_of_speech_filter,
extra_filter):
super().__init__()
config_ini = ConfigIni.getInstance()
self.status_bar = status_bar
self.myFilteredDictionary = FilteredDictionary(
file_name, config_ini.getBaseLanguage(),
config_ini.getLearningLanguage(), part_of_speech_filter,
extra_filter)
good_answer = [""]
self.pos_field = TextLabel("",
font="Courier New",
size=10,
color=Qt.gray)
self.question_field = TextLabel("",
font="Courier New",
size=13,
color=QColor(212, 140, 95))
self.note_field = TextLabel("",
font="Courier New",
size=10,
color=Qt.gray,
bold=True,
italic=True)
self.answer_field = AnswerComplexField(
good_answer,
spacing=AskingCanvas.FIELD_DISTANCE,
font="Courier new",
size=15,
color=Qt.blue,
bg=self.palette().color(QPalette.Background))
#self.answer_field.disableText()
self.good_answer_field = ExpectedAnswerComplexField(
good_answer,
spacing=AskingCanvas.FIELD_DISTANCE,
font="Courier new",
size=15,
color=Qt.black,
bg=self.palette().color(QPalette.Background))
self.result_lamp = ResultLamp(failed_position_list=None)
self.ok_button = OKButton(self)
# --------------------
# general grid setting
# --------------------
#
grid = QGridLayout()
self.setLayout(grid)
grid.setSpacing(1) # space between the fields
# --------------------
# Fields location
# --------------------
fields_columns = 4
# PART OF SPEECH field
grid.addWidget(self.pos_field, 0, 0, 1, fields_columns)
# QUESTION field
grid.addWidget(self.question_field, 1, 0, 1, fields_columns - 1)
# NOTE field
grid.addWidget(self.note_field, 1, fields_columns - 1, 1, 1,
Qt.AlignRight)
# ANSWER field
grid.addWidget(self.answer_field, 5, 0, 1, fields_columns - 1)
# EXPECTED ANSWER field
grid.addWidget(self.good_answer_field, 6, 0, 1, fields_columns - 1)
# OK buttn
grid.addWidget(self.ok_button, 5, fields_columns - 1, 1, 1,
Qt.AlignRight)
# RESULT lamp
grid.addWidget(self.result_lamp, 6, fields_columns - 1, 1, 1,
Qt.AlignRight)
def changeLearningLanguage(self, text):
ConfigIni.getInstance().setLearningLanguage(text)
#if there is NO recor yet
if not self.start_action.isEnabled():
self.asking_canvas.record.setLearningLanguage(text)
self.asking_canvas.myFilteredDictionary.setLearningLanguage(text)
def __init__(self,
file_name="",
part_of_speech_filter="",
extra_filter="",
setup=None):
super().__init__()
# self.file_name = file_name
# self.part_of_speech_filter = part_of_speech_filter
# self.extra_filter = extra_filter
#
# --- Tool Bar ---
#
# OPEN
open_action = QAction(
QIcon(
resource_filename(__name__,
"/".join(("images", "open-tool.png")))),
_("MAIN.TOOLBAR.OPEN"), self)
open_action.setShortcut("Ctrl+O")
open_action.triggered.connect(self.open_dict_file)
# START
self.start_action = QAction(
QIcon(
resource_filename(__name__,
"/".join(("images", "start-tool.png")))),
_("MAIN.TOOLBAR.START"), self)
self.start_action.setShortcut("Ctrl+S")
self.start_action.triggered.connect(self.startClicked)
# SAY OUT
self.sayout_action = QAction(
QIcon(
resource_filename(__name__,
"/".join(("images", "say-tool.png")))),
_("MAIN.TOOLBAR.SAYOUT"), self)
self.sayout_action.setShortcut("Ctrl+T")
self.sayout_action.triggered.connect(self.sayOut)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# QUIT
quit_action = QAction(
QIcon(
resource_filename(__name__,
"/".join(("images", "quit-tool.png")))),
_("MAIN.TOOLBAR.QUIT"), self)
quit_action.setShortcut("Ctrl+Q")
quit_action.triggered.connect(QApplication.instance().quit)
# ENABLE TO SAY
enable_to_say_icon = QIcon()
enable_to_say_icon.addPixmap(
QPixmap(
resource_filename(
__name__, "/".join(
("images", "enable-to-say-on-tool.png")))),
QIcon.Normal, QIcon.On)
enable_to_say_icon.addPixmap(
QPixmap(
resource_filename(
__name__, "/".join(
("images", "enable-to-say-off-tool.png")))),
QIcon.Normal, QIcon.Off)
self.enable_to_say_button = QToolButton()
self.enable_to_say_button.setFocusPolicy(Qt.NoFocus)
self.enable_to_say_button.setIcon(enable_to_say_icon)
self.enable_to_say_button.setCheckable(True)
self.enable_to_say_button.toggled.connect(self.changeEnableToSay)
# ENABLE TO SHOW NOTE
enable_to_show_note_icon = QIcon()
enable_to_show_note_icon.addPixmap(
QPixmap(
resource_filename(
__name__, "/".join(
("images", "enable-to-show-note-on-tool.png")))),
QIcon.Normal, QIcon.On)
enable_to_show_note_icon.addPixmap(
QPixmap(
resource_filename(
__name__, "/".join(
("images", "enable-to-show-note-off-tool.png")))),
QIcon.Normal, QIcon.Off)
self.enable_to_show_note_button = QToolButton()
self.enable_to_show_note_button.setFocusPolicy(Qt.NoFocus)
self.enable_to_show_note_button.setIcon(enable_to_show_note_icon)
self.enable_to_show_note_button.setCheckable(True)
self.enable_to_show_note_button.toggled.connect(
self.changeEnableToShowNote)
# ENABLE TO SHOW PATTERN
enable_to_show_pattern_icon = QIcon()
enable_to_show_pattern_icon.addPixmap(
QPixmap(
resource_filename(
__name__, "/".join(
("images", "enable-to-show-pattern-on-tool.png")))),
QIcon.Normal, QIcon.On)
enable_to_show_pattern_icon.addPixmap(
QPixmap(
resource_filename(
__name__, "/".join(
("images", "enable-to-show-pattern-off-tool.png")))),
QIcon.Normal, QIcon.Off)
self.enable_to_show_pattern_button = QToolButton()
self.enable_to_show_pattern_button.setFocusPolicy(Qt.NoFocus)
self.enable_to_show_pattern_button.setIcon(enable_to_show_pattern_icon)
self.enable_to_show_pattern_button.setCheckable(True)
self.enable_to_show_pattern_button.toggled.connect(
self.changeEnableToShowPattern)
# BASE LANGUAGE DROPDOWN
self.base_language_dropdown = QComboBox(self)
self.base_language_dropdown.setFocusPolicy(Qt.NoFocus)
engine = pyttsx3.init()
voices = engine.getProperty('voices')
#flag = QIcon( resource_filename(__name__, "/".join(("images", "open-tool.png"))) )
#[base_language_dropdown.addItem( flag, removeControlChars( i.languages[0].decode("utf-8") ) ) for i in voices]
# Eliminates the languages having longer name as 2
[
self.base_language_dropdown.addItem(j) for j in [
removeControlChars(i.languages[0].decode("utf-8"))
for i in voices
] if len(j) == 2
]
#[self.base_language_dropdown.addItem( removeControlChars( i.languages[0].decode("utf-8") ) ) for i in voices]
self.base_language_dropdown.activated[str].connect(
self.changeBaseLanguage)
# LEARNING LANGUAGE DROPDOWN
self.learning_language_dropdown = QComboBox(self)
self.learning_language_dropdown.setFocusPolicy(Qt.NoFocus)
#[self.learning_language_dropdown.addItem( removeControlChars( i.languages[0].decode("utf-8") ) ) for i in voices]
# Eliminates the languages having longer name as 2
[
self.learning_language_dropdown.addItem(j) for j in [
removeControlChars(i.languages[0].decode("utf-8"))
for i in voices
] if len(j) == 2
]
self.learning_language_dropdown.activated[str].connect(
self.changeLearningLanguage)
# POS FILTER DROPDOWN
self.pos_filter_dropdown = QComboBox(self)
self.pos_filter_dropdown.setFixedWidth(100)
self.pos_filter_dropdown.setFocusPolicy(Qt.NoFocus)
self.pos_filter_dropdown.activated[str].connect(self.changePOSFilter)
# EXTRA FILTER DROPDOWN
self.extra_filter_dropdown = QComboBox(self)
self.extra_filter_dropdown.setFixedWidth(100)
self.extra_filter_dropdown.setFocusPolicy(Qt.NoFocus)
self.extra_filter_dropdown.activated[str].connect(
self.changeExtraFilter)
#
# Default settings
#
config_ini = ConfigIni.getInstance()
self.sayout_action.setEnabled(False)
self.start_action.setEnabled(False)
self.createAskingCanvas(file_name, part_of_speech_filter, extra_filter,
False)
self.enable_to_say_button.setChecked(config_ini.isSayOut())
self.enable_to_show_note_button.setChecked(config_ini.isShowNote())
self.enable_to_show_pattern_button.setChecked(
config_ini.isShowPattern())
self.base_language_dropdown.setCurrentText(
config_ini.getBaseLanguage())
self.learning_language_dropdown.setCurrentText(
config_ini.getLearningLanguage())
# Selector Toolbar
selectorToolbar = QToolBar("Selector toolbar")
self.addToolBar(Qt.LeftToolBarArea, selectorToolbar)
selectorToolbar.setMovable(False)
selectorToolbar.addWidget(self.pos_filter_dropdown)
selectorToolbar.addWidget(self.extra_filter_dropdown)
#selectorToolbar.addSeparator()
#selectorToolbar.addWidget(self.base_language_dropdown)
#selectorToolbar.addWidget(self.learning_language_dropdown)
# Main Toolbar
mainToolbar = self.addToolBar('Main toolbar')
mainToolbar.addAction(open_action)
mainToolbar.addSeparator()
mainToolbar.addAction(self.start_action)
mainToolbar.addAction(self.sayout_action)
mainToolbar.addSeparator()
mainToolbar.addWidget(self.enable_to_say_button)
mainToolbar.addWidget(self.enable_to_show_note_button)
mainToolbar.addWidget(self.enable_to_show_pattern_button)
mainToolbar.addWidget(self.base_language_dropdown)
mainToolbar.addWidget(self.learning_language_dropdown)
#mainToolbar.addWidget(self.pos_filter_dropdown)
#mainToolbar.addWidget(self.extra_filter_dropdown)
mainToolbar.addSeparator()
mainToolbar.addWidget(spacer)
mainToolbar.addAction(quit_action)
#
# --- Status Bar ---
#
#self.statusBar().showMessage("")
#
# --- Window ---
#
self.setWindowTitle(setup['title'] + " - " + setup['version'])
self.resize(GuiPrala.WIDTH, GuiPrala.HEIGHT)
#self.setFixedHeight(GuiPrala.HEIGHT)
#self.setFixedWidth(GuiPrala.WIDTH)
self.center()
self.show()
def changeEnableToShowNote(self, checked):
ConfigIni.getInstance().setShowNote(checked)
#self.show_note = checked
if (not checked and hasattr(self, 'asking_canvas')):
self.asking_canvas.note_field.setText("")
def changeEnableToSay(self, checked):
ConfigIni.getInstance().setSayOut(checked)