TDE
/
tdeedu
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdeedu
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '92f7753f88'
${ noResults }
tdeedu/ktouch/src/ktouchtrainer.cpp

503 lines
19 KiB
Raw Blame History Escape

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

/***************************************************************************
* ktouchtrainer.cpp *
* ----------------- *
* Copyright (C) 2000 by Håvard Frøiland, 2006 by Andreas Nicolai *
* ghorwin@users.sourceforge.net *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
***************************************************************************/
#include "ktouchtrainer.h"
#include "ktouchtrainer.moc"
#include <tqlcdnumber.h>
#include <tqfile.h>
#include <kdebug.h>
#include <kpushbutton.h>
#include <klocale.h>
#include <kstandarddirs.h>
#include <kaudioplayer.h>
#include <tqmessagebox.h>
#include "ktouch.h"
#include "ktouchstatus.h"
#include "ktouchslideline.h"
#include "ktouchkeyboardwidget.h"
#include "ktouchlecture.h"
#include "ktouchdefaults.h"
#include "prefs.h"
KTouchTrainer::KTouchTrainer(KTouchStatus *status, KTouchSlideLine *slideLine, KTouchKeyboardWidget *keyboard, KTouchLecture *lecture)
: TQObject(),
m_trainingTimer(new TQTimer),
m_statusWidget(status),
m_slideLineWidget(slideLine),
m_keyboardWidget(keyboard),
m_lecture(lecture)
{
m_level = 0; // level 1, but we're storing it zero based
m_line = 0;
m_wordsInCurrentLine = 0;
m_trainingPaused=true; // we start in pause mode
m_teacherText=m_lecture->level(0).line(0);
m_studentText="";
// reset statistics
m_levelStats.clear();
m_sessionStats.clear();
/// \todo preload sounds and improve sound playback system
m_levelUpSound = KGlobal::dirs()->findResource("appdata","up.wav");
m_levelDownSound = KGlobal::dirs()->findResource("appdata","down.wav");
m_typeWriterSound = KGlobal::dirs()->findResource("appdata","typewriter.wav");
connect(m_statusWidget->levelUpBtn, TQT_SIGNAL(clicked()), this, TQT_SLOT(levelUp()) );
connect(m_statusWidget->levelDownBtn, TQT_SIGNAL(clicked()), this, TQT_SLOT(levelDown()) );
connect(m_trainingTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timerTick()) );
}
// ----------------------------------------------------------------------------
KTouchTrainer::~KTouchTrainer() {
delete m_trainingTimer;
}
// ----------------------------------------------------------------------------
void KTouchTrainer::gotoFirstLine() {
m_statusWidget->setNewChars( m_lecture->level(m_level).newChars() );
m_line=0;
newLine();
}
// ----------------------------------------------------------------------------
void KTouchTrainer::keyPressed(TQChar key) {
// NOTE : In this function we need to distinguish between left and right
// typing. Use the config setting Prefs::right2LeftTyping() for that.
if (m_trainingPaused) continueTraining();
if (m_teacherText==m_studentText) {
// if already at end of line, don't add more chars
/// \todo Flash the line when line complete
if (Prefs::beepOnError()) TQApplication::beep();
return;
}
// remember length of student text without added character
unsigned int old_student_text_len = m_studentText.length();
// compose new student text depending in typing direction
TQString new_student_text = m_studentText;
if (Prefs::right2LeftTyping())
new_student_text = key + new_student_text;
else
new_student_text += key;
// don´t allow excessive amounts of characters per line
if (!m_slideLineWidget->canAddCharacter(new_student_text)) {
if (Prefs::beepOnError()) TQApplication::beep();
return;
}
// store the new student text
m_studentText = new_student_text;
// we need to find out, if the key was correct or not
if (studentLineCorrect())
statsAddCorrectChar(key); // ok, all student text is correct
else {
// nope, the key was wrong : beep !!!
if (Prefs::beepOnError()) TQApplication::beep();
// check if the key is the first wrong key that was mistyped. Only then add it
// to the wrong char statistics.
if (Prefs::right2LeftTyping()) {
if (m_teacherText.right(old_student_text_len)==m_studentText.right(old_student_text_len) &&
m_teacherText.length() > old_student_text_len)
{
// add the key the student ought to press to the wrong character stats
int next_key_index = m_teacherText.length() - old_student_text_len;
// kdDebug() << "Wrong key = " << m_teacherText[next_key_index] << endl;
statsAddWrongChar( m_teacherText[next_key_index] );
}
}
else {
if (m_teacherText.left(old_student_text_len)==m_studentText.left(old_student_text_len) &&
m_teacherText.length() > old_student_text_len)
{
// add the key the student ought to press to the wrong character stats
int next_key_index = old_student_text_len;
statsAddWrongChar( m_teacherText[next_key_index] );
}
}
/// \todo Implement option whether subsequent mistyped keys should be remembered as missed
/// keys as well.
}
updateWidgets(); // update all the other widgets (keyboard widget, status widget and statusbar)
}
// ----------------------------------------------------------------------------
void KTouchTrainer::backspacePressed() {
if (m_trainingPaused) continueTraining();
/// \todo Implement the "remove space character = remove word count" feature
unsigned int len = m_studentText.length();
if (len) {
if (m_teacherText.left(len)==m_studentText && m_teacherText.length()>=len) {
// we are removing a correctly typed char
statsRemoveCorrectChar(m_studentText[len-1]);
}
m_studentText = m_studentText.left(--len);
updateWidgets(); // update all the widgets and the word count
if (m_teacherText.left(len)==m_studentText)
m_keyboardWidget->newKey(m_teacherText[len]);
else
m_keyboardWidget->newKey(TQChar(8));
}
else {
/// \todo Flash line when Backspace on empty line
TQApplication::beep();
}
}
// ----------------------------------------------------------------------------
void KTouchTrainer::enterPressed() {
if (m_trainingPaused) continueTraining();
if (m_studentText!=m_teacherText) {
TQApplication::beep();
return;
};
/*
// NOTE : auto level change inside level was removed due to popular request
if (Prefs::autoLevelChange()) {
// if level increase criterion was fulfilled, increase line counter
if (Prefs::upCorrectLimit() <= m_session.correctness()*100 &&
Prefs::upSpeedLimit() <= m_session.charSpeed())
{
m_decLinesCount=0;
++m_incLinesCount;
}
else if (Prefs::downCorrectLimit() > m_session.correctness()*100 ||
Prefs::downSpeedLimit() > m_session.charSpeed())
{
m_incLinesCount=0;
++m_decLinesCount;
};
// Automatic level change after a number of lines can happen, if you fulfilled the
// requirements in the last 5 lines.
if (m_incLinesCount>=2) {
levelUp();
return;
}
if (m_decLinesCount>=2 && m_level!=0) {
levelDown();
return;
};
};
*/
// Check if we are in the last line
if (m_line+1 >= m_lecture->level(m_level).count()) {
if (Prefs::autoLevelChange()) {
// adjust level if limits exceeded
if (Prefs::upCorrectLimit() <= m_levelStats.correctness()*100 &&
Prefs::upSpeedLimit() <= m_levelStats.charSpeed())
{
/// \todo Test if last level is done and show message, stop training, show statistics etc.
levelUp(); // level change takes care of updating word count
return;
}
else if (Prefs::downCorrectLimit() > m_levelStats.correctness()*100 ||
Prefs::downSpeedLimit() > m_levelStats.charSpeed())
{
levelDown(); // level change takes care of updating word count
return;
}
}
// we have to store the word count before continuing in the first line
updateWordCount();
m_levelStats.m_words += m_wordsInCurrentLine;
m_sessionStats.m_words += m_wordsInCurrentLine;
gotoFirstLine(); // restart in the new/current level
}
else {
// store the word count
updateWordCount();
m_levelStats.m_words += m_wordsInCurrentLine;
m_sessionStats.m_words += m_wordsInCurrentLine;
++m_line;
newLine(); // otherwise show next line
}
}
// ----------------------------------------------------------------------------
void KTouchTrainer::updateWidgets() {
// update status widget
m_statusWidget->updateStatus(m_level, m_levelStats.correctness());
// update slide line widget
m_slideLineWidget->setStudentText(m_studentText);
// update keyboard widget -> show next to be pressed char.
// we have to find out first whether the student text is correct or not.
if (studentLineCorrect()) {
// ok, all student text is correct
if (m_teacherText.length()==m_studentText.length())
m_keyboardWidget->newKey(TQChar(13)); // we have reached the end of the line
else
m_keyboardWidget->newKey(m_teacherText[m_studentText.length()]);
}
else {
m_keyboardWidget->newKey(TQChar(8)); // wrong key, user must now press backspace
}
updateWordCount(); // here we first update the word count
updateStatusBar(); // and then the status bar
}
// ----------------------------------------------------------------------------
void KTouchTrainer::startTraining(bool keepLevel) {
// Here we start a new training session.
// keep the current level if flag is set
if (!keepLevel)
m_level=0;
// reset the level and session statistics
m_levelStats.clear();
m_sessionStats.clear();
// transfer level to level statistics
m_levelStats.m_levelNum = m_level;
// remember level in session stats
m_sessionStats.m_levelNums.insert(m_level);
// go to first line in level (also resets word count)
gotoFirstLine();
updateStatusBarMessage(i18n("Starting training session: Waiting for first keypress...") );
updateStatusBar();
m_statusWidget->updateStatus(m_level, 1);
m_statusWidget->speedLCD->display( 0 );
m_trainingPaused=true; // Go into "Pause" mode
m_trainingTimer->stop(); // Training timer will be started on first keypress.
m_slideLineWidget->setCursorTimerEnabled(true); // Curser will blink
updateLevelChangeButtons();
}
// ----------------------------------------------------------------------------
// Pauses the current training session.
// This function is called from class KTouch (when the Pause action is executed).
void KTouchTrainer::pauseTraining() {
m_trainingPaused=true;
m_trainingTimer->stop();
m_slideLineWidget->setCursorTimerEnabled(false);
m_statusWidget->updateStatus(m_level, m_levelStats.correctness());
m_statusWidget->speedLCD->display( m_levelStats.charSpeed() );
updateStatusBarMessage(i18n("Training session paused. Training continues on next keypress...") );
updateStatusBar();
}
// ----------------------------------------------------------------------------
// Continues the current training session.
// This function is called from class KTouch when a user presses a normal key
// while the training is in pause mode.
void KTouchTrainer::continueTraining() {
m_trainingPaused=false;
m_slideLineWidget->setCursorTimerEnabled(true);
m_statusWidget->updateStatus(m_level, m_levelStats.correctness() );
m_statusWidget->speedLCD->display( m_levelStats.charSpeed() );
updateStatusBarMessage(i18n("Training session! The time is running...") );
updateStatusBar();
m_trainingTimer->start(LCD_UPDATE_INTERVAL); // start the timer
}
// ----------------------------------------------------------------------------
void KTouchTrainer::storeTrainingStatistics() {
// at first get a reference to the statistics data of the current lecture
KTouchLectureStats& data = KTouchPtr->getCurrentLectureStats();
// update word count
updateWordCount();
// add word count to level and session statistics
m_levelStats.m_words += m_wordsInCurrentLine;
m_sessionStats.m_words += m_wordsInCurrentLine;
// are there level stats to be stored?
if (m_levelStats.m_elapsedTime != 0) {
//kdDebug() << "[KTouchTrainer::storeTrainingStatistics] Storing level statistics!" << endl;
m_levelStats.m_timeRecorded = TQDateTime::currentDateTime();
data.m_levelStats.push_back( m_levelStats );
}
if (m_sessionStats.m_elapsedTime != 0) {
//kdDebug() << "[KTouchTrainer::storeTrainingStatistics] Storing session statistics!" << endl;
m_sessionStats.m_timeRecorded = TQDateTime::currentDateTime();
data.m_sessionStats.push_back( m_sessionStats );
}
}
// ----------------------------------------------------------------------------
bool KTouchTrainer::studentLineCorrect() const {
if (m_teacherText.isEmpty())
return m_studentText.isEmpty();
unsigned int len = m_studentText.length();
// different check for left and right writing
if (Prefs::right2LeftTyping())
return m_teacherText.right(len)==m_studentText && m_teacherText.length()>=len;
else
return (m_teacherText.left(len)==m_studentText && m_teacherText.length()>=len);
}
// ----------------------------------------------------------------------------
// *** Public slots ***
void KTouchTrainer::levelUp() {
KAudioPlayer::play(m_levelUpSound.url());
++m_level; // increase the level
if (m_level>=m_lecture->levelCount()) {
// already at max level? Let's stay there
m_level=m_lecture->levelCount()-1;
levelAllComplete();
/// \todo Do something when last level is completed
}
// Store level statistics if level is increased
statsChangeLevel();
gotoFirstLine();
updateLevelChangeButtons();
}
// ----------------------------------------------------------------------------
void KTouchTrainer::levelDown() {
if (m_level>0) {
--m_level;
KAudioPlayer::play(m_levelDownSound.url());
}
// Store level statistics if level is increased
statsChangeLevel();
gotoFirstLine();
updateLevelChangeButtons();
}
// ----------------------------------------------------------------------------
void KTouchTrainer::timerTick() {
if (m_trainingPaused) return;
// Add the timer interval. I think we can neglect the error we make when the session is
// paused and continued... it's not a scientific calculation, isn't it?
statsAddTime(LCD_UPDATE_INTERVAL*0.001);
// update only the widgets that are affected by progressing time
m_statusWidget->speedLCD->display( m_levelStats.charSpeed() );
}
// ----------------------------------------------------------------------------
// *** Private functions ***
void KTouchTrainer::levelAllComplete() {
TQMessageBox::information(0, i18n("You rock!"),
i18n("You have finished this training exercise.\n"
"This training session will start from the beginning."));
statsChangeLevel();
startTraining(false);
}
void KTouchTrainer::updateLevelChangeButtons() {
if (!Prefs::disableManualLevelChange()) {
m_statusWidget->levelUpBtn->setEnabled(m_level < m_lecture->levelCount() - 1);
m_statusWidget->levelDownBtn->setEnabled(m_level > 0);
}
}
void KTouchTrainer::newLine() {
m_teacherText = m_lecture->level(m_level).line(m_line);
m_studentText="";
m_wordsInCurrentLine = 0;
m_keyboardWidget->newKey(m_teacherText[0]);
m_slideLineWidget->setNewText(m_teacherText, m_studentText);
updateStatusBar(); // update status bar
}
// ----------------------------------------------------------------------------
void KTouchTrainer::updateStatusBar() const {
KTouchPtr->changeStatusbarStats(m_levelStats.m_correctChars, m_levelStats.m_totalChars,
m_levelStats.m_words + m_wordsInCurrentLine,
m_sessionStats.m_correctChars, m_sessionStats.m_totalChars,
m_sessionStats.m_words + m_wordsInCurrentLine);
}
// ----------------------------------------------------------------------------
void KTouchTrainer::updateStatusBarMessage(const TQString& message) const {
KTouchPtr->changeStatusbarMessage(message);
}
// ----------------------------------------------------------------------------
void KTouchTrainer::updateWordCount() {
// now update the m_wordsInCurrentLine variable
if (!studentLineCorrect()) return; // if error, don't update
int words = 0;
bool space = true;
for (unsigned int i=0; i<m_studentText.length(); ++i) {
bool is_space = (m_studentText[i] == TQChar(' '));
if (is_space) {
if (space) continue; // two spaces after each other... ignore
else {
++words;
space = true;
}
}
else {
if (!space) continue; // two chars after each other... ignore
else {
space = false; // no need to add a word here.
}
}
}
// check if line is completely typed and add a word then
if (m_studentText == m_teacherText) ++words;
m_wordsInCurrentLine = words;
}
// ----------------------------------------------------------------------------
void KTouchTrainer::statsAddCorrectChar(TQChar key) {
m_levelStats.addCorrectChar(key);
m_sessionStats.addCorrectChar(key);
}
// ----------------------------------------------------------------------------
void KTouchTrainer::statsAddWrongChar(TQChar key) {
m_levelStats.addWrongChar(key);
m_sessionStats.addWrongChar(key);
}
// ----------------------------------------------------------------------------
void KTouchTrainer::statsRemoveCorrectChar(TQChar) {
m_levelStats.removeCorrectChar();
m_sessionStats.removeCorrectChar();
}
// ----------------------------------------------------------------------------
void KTouchTrainer::statsAddTime(double dt) {
m_levelStats.m_elapsedTime += dt;
m_sessionStats.m_elapsedTime += dt;
}
// ----------------------------------------------------------------------------
void KTouchTrainer::statsChangeLevel() {
//kdDebug() << "[KTouchTrainer::statsChangeLevel] First!" << endl;
// first update word count and store data in
updateWordCount();
//kdDebug() << "[KTouchTrainer::statsChangeLevel] Adding word count of " << m_wordsInCurrentLine << endl;
m_levelStats.m_words += m_wordsInCurrentLine;
m_sessionStats.m_words += m_wordsInCurrentLine;
// get a reference to the statistics data of the current lecture
KTouchLectureStats& data = KTouchPtr->getCurrentLectureStats();
// are there level stats to be stored?
if (m_levelStats.m_elapsedTime != 0) {
//kdDebug() << "[KTouchTrainer::storeTrainingStatistics] Storing level statistics!" << endl;
m_levelStats.m_timeRecorded = TQDateTime::currentDateTime();
data.m_levelStats.push_back( m_levelStats );
}
// clear level stats
m_levelStats.clear();
// transfer current level to level statistics
m_levelStats.m_levelNum = m_level;
// remember level in session stats
m_sessionStats.m_levelNums.insert(m_level);
// show new level (in status widet) and 100% correctness
m_statusWidget->updateStatus(m_level, 1);
}
// ----------------------------------------------------------------------------
View Git Blame Copy Permalink