#!/usr/bin/python2.5
# -*- coding: utf-8 -*-

#
# WordByWord - a vocabulary trainer
# Copyright (c) 2009 Peter Bouda
#
# WordByWord 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 3 of the License, or
# (at your option) any later version.
#
# WordByWord is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

import os, sys
sys.path.append('lib')
import yaml
import random
import hashlib
import subprocess
from PyQt4 import QtCore, QtGui

# check for availabe audio modules
audio_module = 'none'

try:
    from PyQt4.phonon import Phonon
    audio_module = 'phonon'
except:
    print >>sys.stderr, "no supported audio module found"

def onMaemo():
    if os.environ.has_key("OSSO_PRODUCT_NAME"):
        return True
    else:
        return False

def main():

    wbw_script = sys.argv[0]
    if os.path.islink(wbw_script):
        wbw_script = os.readlink(wbw_script)
    wbw_dir = os.path.join(os.path.dirname(wbw_script), '..')
    prefix = os.path.abspath(os.path.normpath(wbw_dir))

    src_dir = os.path.join(prefix, 'src')
    data_dir = os.path.join(prefix, 'data')
    locale_dir = os.path.join(prefix, 'share', 'locale')
    if onMaemo():
        print >>sys.stderr, "Running on Maemo."
        locale_dir = os.path.join('opt', 'wordbyword', 'locale')

    if os.path.exists(src_dir) and os.path.exists(data_dir) and not prefix.startswith('/usr'):
        # Run WordByWord from local source folder (not installed)
        #print >>sys.stderr, 'Using modules from', src_dir
        #sys.path.insert(0, src_dir)
        print >>sys.stderr, 'Using resources from', data_dir
        locale_dir = os.path.join(data_dir, 'locale')

    # Starting the App
    app = QtGui.QApplication(sys.argv)
    QtGui.QApplication.setApplicationName("WordByWord")

    qtTranslator = QtCore.QTranslator()
    qtTranslator.load("qt_" + unicode(QtCore.QLocale.system().name()), QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.TranslationsPath))
    app.installTranslator(qtTranslator)

    myappTranslator = QtCore.QTranslator()
    if myappTranslator.load("wordbyword_" + unicode(QtCore.QLocale.system().name()), locale_dir):
        app.installTranslator(myappTranslator)
    else:
        print >>sys.stderr, "Could not load translation file wordbyword_" + unicode(QtCore.QLocale.system().name() + " in " + locale_dir)

    MainWindow = WordByWordWindow()
    MainWindow.show()
    sys.exit(app.exec_())

class WordByWordObject:
    def __init__(self,filename):
        self.yml = yaml.load(open(filename, "r"))
        self.filename = filename
        self.currentLesson = None
        self.currentWordIndex = None
        self.currentWordCount = 0

    def setCurrentLesson(self, lesson):
        self.currentLesson = lesson
        self.lessonWords = []
        self.lessonSolutions = []
        self.currentWordCount = 0
        for word in self.yml['vocabulary']['lessons'][lesson].keys():
            self.lessonWords.append(word)
            self.currentWordCount = self.currentWordCount +1 
        random.shuffle(self.lessonWords)
        for word in self.lessonWords:
            self.lessonSolutions.append(self.yml['vocabulary']['lessons'][lesson][word])
        self.currentWordIndex = 0

    def nextWord(self):
        if self.currentWordIndex+1 < self.currentWordCount:
            self.currentWordIndex = self.currentWordIndex + 1

    def multiplechoice(self):
        ret = [ self.currentSolution() ]
        length = 3
        if self.currentWordCount < 3:
            length = self.currentWordCount
        while len(ret) < length:
            i = random.randint(0, self.currentWordCount - 1)
            word = self.lessonSolutions[i]
            if not word in ret:
                ret.append(word)
        random.shuffle(ret)
        return ret

    def prevWord(self):
        if self.currentWordIndex > 0:
            self.currentWordIndex = self.currentWordIndex - 1

    def lessonTitles(self):
        ret = self.yml['vocabulary']['lessons'].keys()
        ret.sort()
        return ret

    def currentSolution(self):
        return self.lessonSolutions[self.currentWordIndex]

    def currentWord(self):
        return self.lessonWords[self.currentWordIndex]

    def langtts(self):
        return self.yml['vocabulary']['langtts']

class WordByWordWindow(QtGui.QMainWindow):
    """The main window of the WordByWord application."""
    
    def __init__(self, *args):
        QtGui.QMainWindow.__init__(self, *args)
        self.wbwObject = None
        self.lessonsDialog = None
        self.media = None
        self.radiobuttonsSolution = None 
        self.initDirs()

        # Play mp3 on Windows and Mac and ogg elsewhere
        if os.name == 'nt' or os.name == 'mac':
            self.audiotype = "mp3"
        else:
            self.audiotype = "ogg"
        print >>sys.stderr, "Play audio type %s" % self.audiotype

        self.setObjectName("MainWindow")
        self.setWindowTitle("WordByWord")
        fontsizelabel = 16
        if os.environ.has_key("OSSO_PRODUCT_NAME"):
            fontsizelabel = 24
        if not os.environ.has_key("OSSO_PRODUCT_NAME"): 
            self.setStyleSheet("QMainWindow { background: white url(%s); background-repeat: repeat-x; } \
                                QLabel#labelDisplayArea { font-family: serif; color:blue; font-size:%spx; font-weight:bold; } \
                                QLabel#labelSolution { font-family: serif; color:blue; font-size:%spx; font-weight:bold; }" % (self.background_file, fontsizelabel, fontsizelabel))
            self.resize(700, 400)
        self.hboxLayoutWidget = QtGui.QWidget(self)
        self.hboxLayout = QtGui.QHBoxLayout(self.hboxLayoutWidget)
        self.hboxLayout.setSizeConstraint(QtGui.QLayout.SetDefaultConstraint)

        self.hboxLayout.addWidget(self.controlButtons())
        self.hboxLayout.addWidget(self.displayArea())

        self.hboxLayoutWidget.setLayout(self.hboxLayout)
        self.setCentralWidget(self.hboxLayoutWidget)

        if os.environ.has_key("OSSO_PRODUCT_NAME"):
          self.initMenuMaemo()
        else:
          self.initMenu()
        self.initSignals()
        self.actionModeDisplayOnly.setChecked(True)
        filename = ''
        if len(sys.argv) > 1:
            filename = sys.argv[1]
        elif (os.path.exists('start.ini')):
            startfile = open('start.ini', 'r')
            filename = startfile.readline().rstrip('\n')
        if filename != '' and os.path.exists(filename):
            self.wbwObject = WordByWordObject(filename)
            self.initLessons()
            self.showCurrentWord()

    def displayArea(self):
        widgetDisplayArea = QtGui.QWidget(self)
        vboxLayoutDisplayArea = QtGui.QVBoxLayout(widgetDisplayArea)
        #vboxLayoutDisplayArea.setSizeConstraint(QtGui.QLayout.SetDefaultConstraint)
        vboxLayoutDisplayArea.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
        vboxLayoutDisplayArea.setContentsMargins(50, QtGui.QStyle.PM_LayoutTopMargin, QtGui.QStyle.PM_LayoutRightMargin, QtGui.QStyle.PM_LayoutBottomMargin)


        self.labelDisplayArea = QtGui.QLabel(self.tr("Please open a file"))
        self.labelDisplayArea.setFixedWidth(400)
        self.labelDisplayArea.setWordWrap(True)
        self.labelDisplayArea.setObjectName("labelDisplayArea")
        #self.labelDisplayArea.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
        vboxLayoutDisplayArea.addWidget(self.labelDisplayArea)

        self.widgetDisplayAdditional = QtGui.QWidget(widgetDisplayArea)
        vboxLayoutDisplayAdditional = QtGui.QVBoxLayout(self.widgetDisplayAdditional)
        self.widgetDisplayAdditional.setLayout(vboxLayoutDisplayAdditional)
        vboxLayoutDisplayArea.addWidget(self.widgetDisplayAdditional)
 
        self.labelSolution = QtGui.QLabel("")
        self.labelSolution.setWordWrap(True)
        self.labelSolution.setObjectName("labelSolution")
        vboxLayoutDisplayArea.addWidget(self.labelSolution)
        self.labelCorrectOrNot = QtGui.QLabel("")
        self.labelCorrectOrNot.font().setPixelSize(14)
        vboxLayoutDisplayArea.addWidget(self.labelCorrectOrNot)
        self.buttonListen = QtGui.QPushButton(self.tr("Read Solution"))
        self.buttonListen.setDisabled(True)
        vboxLayoutDisplayArea.addWidget(self.buttonListen)

        widgetDisplayArea.setLayout(vboxLayoutDisplayArea)
        return widgetDisplayArea

    def controlButtons(self):
        widgetControlButtons = QtGui.QWidget(self)
        vboxLayout = QtGui.QVBoxLayout(widgetControlButtons)
        vboxLayout.setSizeConstraint(QtGui.QLayout.SetDefaultConstraint)
        self.buttonOpen = QtGui.QPushButton(self.tr("Open"), self)
        vboxLayout.addWidget(self.buttonOpen)
        self.buttonPrev = QtGui.QPushButton(self.tr("Previous"), self)
        self.buttonPrev.setEnabled(False)
        vboxLayout.addWidget(self.buttonPrev)
        self.buttonNext = QtGui.QPushButton(self.tr("Next"), self)
        self.buttonNext.setEnabled(False)
        vboxLayout.addWidget(self.buttonNext)
        self.buttonSolution = QtGui.QPushButton(self.tr("Solution"), self)
        self.buttonSolution.setEnabled(False)
        vboxLayout.addWidget(self.buttonSolution)
        widgetControlButtons.setLayout(vboxLayout)
        widgetControlButtons.setFixedSize(150,350)
        return widgetControlButtons

    def initMenu(self):
        # Open
        self.actionOpenFile = QtGui.QAction(self.tr("Open File..."), self)
        self.actionOpenFile.setObjectName("actionOpenFile")
        # Quit
        self.actionQuit = QtGui.QAction(self.tr("Quit"), self)
        self.actionQuit.setMenuRole(QtGui.QAction.QuitRole)
        self.actionQuit.setObjectName("actionQuit")
        self.actionLessons = QtGui.QAction(self.tr("Lessons..."), self)

        fileMenu = self.menuBar().addMenu(self.tr("File"))
        fileMenu.addAction(self.actionOpenFile)
        fileMenu.addAction(self.actionLessons)
        fileMenu.addSeparator()
        fileMenu.addAction(self.actionQuit)

        # Modes
        self.actiongroupModes = QtGui.QActionGroup(self)
        self.actionModeDisplayOnly = QtGui.QAction(self.tr("Display only"), self.actiongroupModes)
        self.actionModeDisplayOnly.setCheckable(True)
        self.actiongroupModes.addAction(self.actionModeDisplayOnly)
        self.actionModeMultipleChoice = QtGui.QAction(self.tr("Multiple choice"), self.actiongroupModes)
        self.actionModeMultipleChoice.setCheckable(True)
        self.actiongroupModes.addAction(self.actionModeMultipleChoice)
        self.actionModeInputField = QtGui.QAction(self.tr("Input field"), self.actiongroupModes)
        self.actionModeInputField.setCheckable(True)
        self.actiongroupModes.addAction(self.actionModeInputField)
        self.actiongroupModes.setExclusive(True)
        modesMenu = self.menuBar().addMenu(self.tr("Mode"))
        modesMenu.addActions(self.actiongroupModes.actions())
        #self.menuModes.addActions(self.actiongroupModes.actions())

        # Lessons
        #actionLessons = QtGui.QAction(self.tr("no file loaded"), self)
        #actionLessons.setDisabled(True)
        #self.menuLessons = self.menuBar().addMenu(self.tr("Lesson"))
        #self.menuLessons.addAction(actionLessons)

        # About
        self.actionAboutWordByWord = QtGui.QAction(self.tr("WordByWord..."), self)
        self.actionAboutWordByWord.setMenuRole(QtGui.QAction.AboutRole)	
        self.actionAboutWordByWord.setObjectName("actionAboutWordByWord")
        self.actionDonate = QtGui.QAction(self.tr("Donate..."), self)

        aboutMenu = self.menuBar().addMenu(self.tr("About"))
        aboutMenu.addAction(self.actionAboutWordByWord)
        aboutMenu.addAction(self.actionDonate)

    def initMenuMaemo(self):
        # Open
        self.actionOpenFile = QtGui.QAction(self.tr("Open File"), self)
        self.actionNewFile = QtGui.QAction(self.tr("New File"), self)
        self.actionEditFile = QtGui.QAction(self.tr("Edit File"), self)

        self.actionLessons = QtGui.QAction(self.tr("Lessons"), self)

        self.actiongroupModes = QtGui.QActionGroup(self)
        self.actionModeDisplayOnly = QtGui.QAction(self.tr("Display only"), self.actiongroupModes)
        self.actionModeDisplayOnly.setCheckable(True)
        self.actiongroupModes.addAction(self.actionModeDisplayOnly)
        self.actionModeMultipleChoice = QtGui.QAction(self.tr("Multiple choice"), self.actiongroupModes)
        self.actionModeMultipleChoice.setCheckable(True)
        self.actiongroupModes.addAction(self.actionModeMultipleChoice)
        self.actionModeInputField = QtGui.QAction(self.tr("Input field"), self.actiongroupModes)
        self.actionModeInputField.setCheckable(True)
        self.actiongroupModes.addAction(self.actionModeInputField)
        self.actiongroupModes.setExclusive(True)

        self.actionAboutWordByWord = QtGui.QAction(self.tr("About"), self)
        self.actionAboutWordByWord.setMenuRole(QtGui.QAction.AboutRole)	
        self.actionDonate = QtGui.QAction(self.tr("Donate"), self)

        menu = self.menuBar().addMenu(self.tr(""))
        menu.addAction(self.actionOpenFile)
        menu.addAction(self.actionNewFile)
        menu.addAction(self.actionEditFile)
        menu.addAction(self.actionLessons)
        menu.addActions(self.actiongroupModes.actions())
        menu.addAction(self.actionAboutWordByWord)
        menu.addAction(self.actionDonate)


    def initSignals(self):
        if hasattr(self, 'actionQuit'):
          QtCore.QObject.connect(self.actionQuit, QtCore.SIGNAL("triggered()"), self.close)
        if hasattr(self, 'actionNewFile'):
          QtCore.QObject.connect(self.actionNewFile, QtCore.SIGNAL("triggered()"), self.newFile)
        if hasattr(self, 'actionEditFile'):
          QtCore.QObject.connect(self.actionEditFile, QtCore.SIGNAL("triggered()"), self.editFile)
        QtCore.QObject.connect(self.actionOpenFile, QtCore.SIGNAL("triggered()"), self.fileBrowser)
        QtCore.QObject.connect(self.actionLessons, QtCore.SIGNAL("triggered()"), self.lessonsWindow)
        QtCore.QObject.connect(self.actionAboutWordByWord, QtCore.SIGNAL("triggered()"), self.aboutDialog)
        QtCore.QObject.connect(self.actionDonate, QtCore.SIGNAL("triggered()"), self.donateDialog)
        QtCore.QObject.connect(self.buttonOpen, QtCore.SIGNAL("clicked()"), self.fileBrowser)
        QtCore.QObject.connect(self.buttonPrev, QtCore.SIGNAL("clicked()"), self.prevWord)
        QtCore.QObject.connect(self.buttonNext, QtCore.SIGNAL("clicked()"), self.nextWord)
        QtCore.QObject.connect(self.buttonSolution, QtCore.SIGNAL("clicked()"), self.showSolution)
        QtCore.QObject.connect(self.buttonListen, QtCore.SIGNAL("clicked()"), self.listenSolution)
        QtCore.QObject.connect(self.actionModeDisplayOnly, QtCore.SIGNAL("changed()"), self.setMode)
        QtCore.QObject.connect(self.actionModeMultipleChoice, QtCore.SIGNAL("changed()"), self.setMode)
        QtCore.QObject.connect(self.actionModeInputField, QtCore.SIGNAL("changed()"), self.setMode)
        QtCore.QMetaObject.connectSlotsByName(self)

    def initDirs(self):
        wbw_script = sys.argv[0]
        if os.path.islink(wbw_script):
            wbw_script = os.readlink(wbw_script)
        wbw_dir = os.path.join(os.path.dirname(wbw_script), '..')
        prefix = os.path.abspath(os.path.normpath(wbw_dir))

        self.src_dir = os.path.join(prefix, 'src')
        self.data_dir = os.path.join(prefix, 'data')
        self.courses_dir =  os.path.join(prefix, 'share', 'wordbyword', 'courses')
        self.courses_audio_dir =  os.path.join(prefix, 'share', 'wordbyword', 'courses')
        self.background_file = os.path.join(prefix, 'share', 'wordbyword', 'background.png')

        if onMaemo():
            self.courses_audio_dir =  os.path.join('opt', 'wordbyword', 'courses')
            self.courses_dir =  os.path.join('home', 'user', 'MyDocs', '.documents', 'wordbyword')

        if os.path.exists(self.src_dir) and os.path.exists(self.data_dir) and not prefix.startswith('/usr'):
            # Run WordByWord from local source folder (not installed)
            #print >>sys.stderr, 'Using modules from', src_dir
            #sys.path.insert(0, src_dir)
            print >>sys.stderr, 'Using resources from', self.data_dir
            self.courses_dir =  os.path.join(self.data_dir, 'courses')
            self.courses_audio_dir =  self.courses_dir
            self.background_file = os.path.join(self.data_dir, 'background.png')

    def aboutDialog(self):
        about = QtGui.QMessageBox(self)
        about.setTextFormat(QtCore.Qt.RichText)
        about.setWindowTitle(self.tr("About WordByWord"))
        about.setText(self.tr("<b>WordByWord 0.2.0</b><br/>vocabulary trainer by Peter Bouda.<br/><br/>All rights reserved. See LICENSE file for details.<br/><br/>For more information visit the website:<br/><a href=\"http://www.peterbouda.de/downloads/wordbyword\">http://www.peterbouda.de/downloads/wordbyword</a><br/><br/>Audio files were produced with <a href=\"http://www.linguatec.de/products/tts/voice_reader/vrs\">Linguatec's Voice Reader Studio</a>."))
        about.exec_()

    def donateDialog(self):
        donate = QtGui.QMessageBox(self)
        donate.setTextFormat(QtCore.Qt.RichText)
        donate.setWindowTitle(self.tr("Donate for WordByWord"))
        donate.setText(self.tr("Please donate as much as you like if you find this software useful.<br/><b>Do you want to donate via Paypal now?</b>"))
        donate.setStandardButtons(QtGui.QMessageBox.Yes | QtGui.QMessageBox.No)
        donate.setDefaultButton(QtGui.QMessageBox.Yes)
        ret = donate.exec_()
        if ret == QtGui.QMessageBox.Yes:
            QtGui.QDesktopServices.openUrl(QtCore.QUrl("https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=VXN9T26P6HVLG"))

    def prevWord(self):
        self.wbwObject.prevWord()
        self.setDisplayArea()
        self.buttonListen.setDisabled(True)

    def nextWord(self):
        self.wbwObject.nextWord()
        self.setDisplayArea()
        self.buttonListen.setDisabled(True)

    def showSolution(self):
        s = self.wbwObject.currentSolution()
        h = hashlib.md5(s.encode("utf-8")).hexdigest()
        if os.path.exists("%s/audio/%s/%s.%s" % (self.courses_audio_dir, self.wbwObject.langtts(), h, self.audiotype)) and audio_module != 'none':
            self.buttonListen.setDisabled(False)
        self.labelSolution.setText(s)
        if self.currentMode > 1:
            solution = ""
            if self.currentMode == 2:
                for radiobutton in self.radiobuttonsSolution:
                    if radiobutton.isChecked():
                        solution = radiobutton.text()
            if self.currentMode == 3:
                solution = self.inputfieldSolution.text()
            if solution == self.wbwObject.currentSolution():
                self.labelCorrectOrNot.setText(self.tr("This was the correct answer!"))
            else:
                self.labelCorrectOrNot.setText(self.tr("Sorry, wrong answer :-("))

    def listenSolution(self):
        s = self.wbwObject.currentSolution()
        h = hashlib.md5(s.encode("utf-8")).hexdigest()
        mp3 = "%s/audio/%s/%s.%s" % (self.courses_audio_dir, self.wbwObject.langtts(), h, self.audiotype)
        if os.path.exists(mp3) and audio_module != 'none':
            if not self.media:
                self.media = Phonon.MediaObject(self)
                audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
                Phonon.createPath(self.media, audioOutput)
            self.media.setCurrentSource(Phonon.MediaSource(os.path.abspath(mp3)))
            self.media.play()

    def setMode(self):
        if self.actionModeDisplayOnly.isChecked():
            self.currentMode = 1
        elif self.actionModeMultipleChoice.isChecked():
            self.currentMode = 2
        elif self.actionModeInputField.isChecked():
            self.currentMode = 3
        self.setDisplayArea()
        self.buttonListen.setDisabled(True)

    def fileBrowser(self):
        filename = QtGui.QFileDialog.getOpenFileName(self, self.tr("Select File"), self.courses_dir, "YAML (*.yml)")
        filename = unicode(filename)
        if filename != '':
            self.wbwObject = WordByWordObject(filename)
            #self.initLessons()
            lessons = self.wbwObject.lessonTitles()
            self.setLesson(lessons[0])
            self.showCurrentWord()

    def newFile(self):
        if os.path.exists('/usr/bin/pygtkeditor'):
            filename = QtGui.QFileDialog.getSaveFileName(self, self.tr("New File"), os.path.join(self.courses_dir, 'new.yml'), "YAML (*.yml)")
            f = open(filename, 'w')
            f.write('# This is a demo file\n\nvocabulary:\n  title: "My Title"\n  langtts: "none"\n  lessons:\n    "Title of Lesson 1":\n      "First Word": "Translation"\n    "Title of Lesson 2":\n      "First Word of Lesson 2": "Translation"')
            f.close()
            self.startPygtkeditor(filename)
        else:
            self.pygtkeditorNotFound()

    def editFile(self):
        if self.wbwObject == None:
            QtGui.QMessageBox.warning(self, self.tr("No File Loaded"), self.tr("Please open a file and then start to edit it."))
            return
        if os.path.exists('/usr/bin/pygtkeditor'):
            self.startPygtkeditor(self.wbwObject.filename)
        else:
            self.pygtkeditorNotFound()

    def startPygtkeditor(self, filename):
        QtGui.QMessageBox.information(self, self.tr("Starting PyGTKEditor"), self.tr("PyGTKEditor will be started. Please edit the file, save it and then (re-)open it here."))
        subprocess.Popen(['/usr/bin/pygtkeditor', filename])

    def pygtkeditorNotFound(self):
            QtGui.QMessageBox.warning(self, self.tr("PyGTKEditor not found"), self.tr("Files can only be created or edited when PyGTKEditor is installed. Please install PyGTKEditor with the application manager."))

    def lessonsWindow(self):
        if self.wbwObject == None:
            dialog = QtGui.QMessageBox(self)
            dialog.setWindowTitle(self.tr("No File Loaded"))
            dialog.setText(self.tr("Please open a file and choose a lesson then."))
            dialog.exec_()
            return
        
    def lessonsWindow(self):
        if self.wbwObject == None:
            dialog = QtGui.QMessageBox(self)
            dialog.setWindowTitle(self.tr("No File Loaded"))
            dialog.setText(self.tr("Please open a file and choose a lesson then."))
            dialog.exec_()
            return

        lessons = self.wbwObject.lessonTitles()
        self.lessonsDialog = QtGui.QDialog()
        scrollarea = QtGui.QScrollArea(self.lessonsDialog)
        groupbox = QtGui.QGroupBox(scrollarea)
        #groupbox.setTitle(self.tr("Choose a lesson"))
        layout = QtGui.QVBoxLayout()
        for lesson in lessons:
            pushButton = QtGui.QPushButton(lesson)
            layout.addWidget(pushButton)
            #lessonChanged = QtCore.pyqtSignal(lesson = lesson, name = setLesson
            QtCore.QObject.connect(pushButton, QtCore.SIGNAL("clicked()"), self.setLesson)
        closeButton = QtGui.QPushButton(self.tr("Close this window"))
        closeButton.isDefault()
        QtCore.QObject.connect(closeButton, QtCore.SIGNAL("clicked()"), self.lessonsDialog.accept)
        layout.addWidget(closeButton)
        groupbox.setLayout(layout)
        scrollarea.setWidget(groupbox)
        layout_dialog = QtGui.QVBoxLayout()
        layout_dialog.addWidget(scrollarea)
        self.lessonsDialog.setLayout(layout_dialog)
        if not os.environ.has_key("OSSO_PRODUCT_NAME"):
            self.lessonsDialog.setFixedSize(closeButton.width()+80,500)
        self.lessonsDialog.exec_()

    def initLessons(self):
        lessons = self.wbwObject.lessonTitles()
        self.menuLessons.clear()
        self.actiongroupLessons = QtGui.QActionGroup(self.menuLessons)
        for lesson in lessons:
            actionLesson = QtGui.QAction(lesson, self.actiongroupLessons)
            actionLesson.setCheckable(True)
            self.actiongroupLessons.addAction(actionLesson)
            QtCore.QObject.connect(actionLesson, QtCore.SIGNAL("changed()"), self.setLesson)              
        self.menuLessons.addActions(self.actiongroupLessons.actions())
        self.actiongroupLessons.actions()[0].setChecked(True)
        self.buttonListen.setDisabled(True)

    def setNextButtonState(self):
        if self.wbwObject.currentWordIndex + 1 < self.wbwObject.currentWordCount:
            self.buttonNext.setEnabled(True)
        else:
            self.buttonNext.setEnabled(False)

    def setPrevButtonState(self):
        if self.wbwObject.currentWordIndex > 0:
            self.buttonPrev.setEnabled(True)
        else:
            self.buttonPrev.setEnabled(False)

    def setSolutionButtonState(self):
        self.buttonSolution.setEnabled(True)

    def setDisplayArea(self):
        if self.wbwObject == None:
            return
        self.labelDisplayArea.setText(self.wbwObject.currentWord())
        # delete all stuff in additional area
        has_children = True
        while has_children:
            child = self.widgetDisplayAdditional.layout().takeAt(0)
            if child == None:
                has_children = False
            else:
                child.widget().setParent(None)
        if self.currentMode == 1:
            self.labelDisplayArea.setText(self.wbwObject.currentWord())
        else:
            if self.currentMode == 2:
                words = self.wbwObject.multiplechoice()
                self.radiobuttonsSolution = []
                for word in words:
                    button = QtGui.QRadioButton(word, self.widgetDisplayAdditional)
                    self.widgetDisplayAdditional.layout().addWidget(button)
                    self.radiobuttonsSolution.append(button)
            if self.currentMode == 3:
                self.inputfieldSolution = QtGui.QLineEdit(self.widgetDisplayAdditional)
                self.inputfieldSolution.setFixedWidth(300)
                self.widgetDisplayAdditional.layout().addWidget(self.inputfieldSolution)
                
        self.labelSolution.setText("")
        self.labelCorrectOrNot.setText("")
        self.setNextButtonState()
        self.setPrevButtonState()
        self.setSolutionButtonState()

    def setLesson(self, lesson = None):
        if self.sender and lesson == None:
            lesson = unicode(self.sender().text())
            self.lessonsDialog.accept()
        self.wbwObject.setCurrentLesson(lesson)
        self.setWindowTitle("%s - WordByWord" % self.wbwObject.currentLesson)
        self.setDisplayArea()
      
    def showCurrentWord(self):
        pass


main()
