~s-cecilio/lenmus/trunk

//---------------------------------------------------------------------------------------

//    LenMus Phonascus: The teacher of music

//    Copyright (c) 2010-2015 LenMus project

//

//    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 3 of the License, or (at your option) any later version.

//

//    This program 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/>.

//

//    For any comment, suggestion or feature request, please contact the manager of

//    the project at cecilios@users.sourceforge.net

//

//---------------------------------------------------------------------------------------

#ifndef __LENMUS_EXERCISE_CTROL_H__        //to avoid nested includes

#define __LENMUS_EXERCISE_CTROL_H__

//lenmus

#include "lenmus_standard_header.h"

#include "lenmus_dyncontrol.h"

#include "lenmus_constrains.h"

#include "lenmus_counters_ctrol.h"

#include "lenmus_events.h"

//wxWidgets

#include <wx/wxprec.h>

#include <wx/wx.h>

#include <wx/event.h>

//lomse

#include <lomse_events.h>

#include <lomse_hyperlink_ctrl.h>

#include <lomse_player_gui.h>

#include <lomse_button_ctrl.h>

using namespace lomse;

namespace lenmus

{

// forward declarations

class DocumentCanvas;

class ProblemManager;

class CountersCtrol;

class ProblemDisplayer;

//--------------------------------------------------------------------------------

// An abstract class for any kind of Ctrol included in an eBook.

class EBookCtrol : public DynControl, public EventHandler, public PlayerNoGui

{

protected:

    DocumentWindow*     m_pCanvas;

    EBookCtrolOptions*  m_pBaseConstrains;

    ImoDynamic*         m_pDyn;

    Document*           m_pDoc;

    bool                m_fControlsCreated;

    int                 m_state;        //interal state (FSM)

    ImoId               m_dynId;

    EBookCtrol(long dynId, ApplicationScope& appScope, DocumentWindow* pCanvas);

public:

    virtual ~EBookCtrol();

    //implementation of virtual pure in parent DynControl

    void generate_content(ImoDynamic* pDyn, Document* pDoc);

    virtual void handle_event(SpEventInfo pEvent);

    virtual void get_ctrol_options_from_params() = 0;

    virtual void initialize_ctrol() = 0;

    //virtual pure event handlers to be implemented by derived classes

    virtual void on_debug_show_source_score()=0;

    virtual void on_debug_show_midi_events()=0;

    //event handlers. No need to implement in derived classes

    virtual void on_settings_button();

    virtual void on_go_back();

    //overrides of PlayerNoGui for using general metronome for speed settings

    int get_metronome_mm();

    Metronome* get_metronome();

    //access to parent window

    wxWindow* get_parent_window();

protected:

    //virtual methods to be implemented by derived classes

    virtual void initialize_strings()=0;

    virtual wxDialog* get_settings_dialog()=0;

    virtual void on_settings_changed()=0;

private:

//    void do_stop_sounds();

};

//---------------------------------------------------------------------------------------

// An abstract class for any kind of exercise included in an eBook.

class ExerciseCtrol : public EBookCtrol

{

protected:

    ExerciseCtrol(long dynId, ApplicationScope& appScope, DocumentWindow* pCanvas);

public:

    virtual ~ExerciseCtrol();

    //mandatory override for EventHandler

    virtual void handle_event(SpEventInfo pEvent);

    //event handlers. No need to implement in derived classes

    virtual void on_resp_button(int iButton);

    virtual void on_new_problem();

    virtual void on_display_solution();

    virtual void on_button_mouse_in(SpEventMouse pEvent);

    virtual void on_button_mouse_out(SpEventMouse pEvent);

    //other

    virtual void OnQuestionAnswered(int iQ, bool fSuccess);

    inline int get_generation_mode() { return m_nGenerationMode; }

    void change_generation_mode(int nMode);

    static void on_exercise_activated(void* pThis, SpEventInfo pEvent);

protected:

    //virtual methods to be implemented by derived classes

    virtual void create_answer_buttons(LUnits height, LUnits spacing) = 0;

    virtual wxString set_new_problem()=0;

    virtual void play(bool fVisualTracking=true)=0;

    virtual void stop_sounds()=0;

    virtual void play_specific_sound(int nButton)=0;

    virtual void display_solution()=0;

    virtual void display_problem_score()=0;

    virtual void delete_scores()=0;

    virtual void set_problem_space()=0;

    //methods that, normally, it is not necessary to override in derived classes

    virtual void set_button_color(int i, Color color);

    virtual void enable_buttons(bool fEnable);

    virtual void new_problem();

    virtual void reset_exercise();

    virtual void set_event_handlers();

    virtual void create_problem_display_box(ImoContent* pWrapper, ImoStyle* pStyle=NULL);

    virtual bool is_play_button_initially_enabled();

    virtual bool check_success(int nButton);

    virtual void display_first_time_content();

    virtual string get_initial_msge();

    //methods invoked from derived classes

    virtual void create_controls();

    void set_buttons(ButtonCtrl* pButton[], int nNumButtons);

    //internal methods

    CountersCtrol* create_counters_ctrol(ImoContent* pWrapper);

    void create_problem_manager();

    void change_from_learning_to_practising();

    void display_initial_msge();

    void create_display_and_counters();

    //helper

    inline bool is_learning_mode() { return m_nGenerationMode == k_learning_mode; }

    inline bool is_solution_displayed() { return m_fSolutionDisplayed; }

    inline bool is_theory_mode() {

        return (static_cast<ExerciseOptions*>( m_pBaseConstrains ))->is_theory_mode();

    }

    //wrappers for event handlers

    static void on_new_problem(void* pThis, SpEventInfo pEvent);

    static void on_play_event(void* pThis, SpEventInfo pEvent);

    //static void on_end_of_play_event(void* pThis, SpEventInfo pEvent);

    static void on_display_solution(void* pThis, SpEventInfo pEvent);

    static void on_settings(void* pThis, SpEventInfo pEvent);

    static void on_see_source_score(void* pThis, SpEventInfo pEvent);

    static void on_see_midi_events(void* pThis, SpEventInfo pEvent);

    static void on_go_back_event(void* pThis, SpEventInfo pEvent);

    void change_counters_ctrol();

    void remove_counters_ctrol();

        // member variables

    //display control variables

    ImoScore*       m_pScoreToPlay;

    ProblemDisplayer* m_pDisplay;

    CountersCtrol*  m_pCounters;

    bool            m_fCountersValid;   //when changing mode counters might not be valid

    ImoContent*     m_pCountersWrapper;

    ImoParagraph*   m_pCountersPara;

    bool                m_fQuestionAsked;   //question asked but not yet answered

    int                 m_nRespIndex;       //index to the button with the right answer

    int                 m_nRespAltIndex;    //alternative right answer (i.e. enarmonic answer)

    wxString            m_sAnswer;          //string with the right answer

    bool                m_fSolutionDisplayed;

    HyperlinkCtrl*     m_pPlayButton;      // "play" button

    HyperlinkCtrl*     m_pNewProblem;      //"New problem" link

    HyperlinkCtrl*     m_pShowSolution;    //"Show solution" link

    int                 m_nNumButtons;      //num answer buttons

    ButtonCtrl**        m_pAnswerButtons;   //buttons for the answers

    long                m_nIdFirstButton;   //ID of first button; the others in sequence

    //to generate problems

    int                     m_nGenerationMode;

    int                     m_nProblemLevel;

    ProblemManager*         m_pProblemManager;

    int                     m_iQ;               //index of asked question

    wxString                m_sKeyPrefix;

    //to measure times

    wxDateTime              m_tmAsked;      //when was asked last question

private:

//    void do_stop_sounds();

    void do_display_solution();

};

//---------------------------------------------------------------------------------------

// Abstract class to create exercise to compare scores/sounds

class CompareCtrol : public ExerciseCtrol

{

public:

    // constructor and destructor

    CompareCtrol(long dynId, ApplicationScope& appScope, DocumentWindow* pCanvas);

    virtual ~CompareCtrol();

    enum {

        k_num_rows = 1,

        k_num_cols = 3,

        k_num_buttons = 3,

        m_ID_BUTTON = 3010,

    };

protected:

    //virtual methods implemented in this class

    void create_answer_buttons(LUnits height, LUnits spacing);

    virtual void initialize_strings();

protected:

    // member variables

    ButtonCtrl*     m_pAnswerButton[k_num_buttons];   //buttons for the answers

};

//---------------------------------------------------------------------------------------

// Abstract class to create exercise to compare two scores

class CompareScoresCtrol : public wxEvtHandler, public CompareCtrol

{

public:

    // constructor and destructor

    CompareScoresCtrol(long dynId, ApplicationScope& appScope, DocumentWindow* pCanvas);

    virtual ~CompareScoresCtrol();

    //implementation of virtual event handlers

    virtual void on_debug_show_source_score();

    virtual void on_debug_show_midi_events();

    virtual void on_end_of_playback();

protected:

    //implementation of some virtual methods

    void play(bool fVisualTracking=true);

    void play_specific_sound(int nButton) {}

    void display_solution();

    void display_problem_score();

    void delete_scores();

    void stop_sounds();

protected:

    // wxWidgets event handlers

    void on_timer_event(wxTimerEvent& WXUNUSED(event));

    ScorePlayer*    m_pPlayer;

    ImoScore*       m_pScore[2];        //the two problem scores

    int             m_nNowPlaying;      //score being played (0, 1)

    wxTimer         m_oPauseTimer;      //timer to do a pause between the two scores

    ImoScore*       m_pSolutionScore;   //solution score

    int             m_nPlayMM;          //metronome setting to play the scores

    bool            m_fPlayingProblem;  //currently playing the score (might be waiting for timer event)

private:

    void PlayScore(int nIntv, bool fVisualTracking);

    wxDECLARE_CLASS(CompareScoresCtrol);

};

//---------------------------------------------------------------------------------------

// Abstract class to create exercises with one problem score

class OneScoreCtrol : public ExerciseCtrol

{

protected:

    OneScoreCtrol(long dynId, ApplicationScope& appScope, DocumentWindow* pCanvas);

public:

    virtual ~OneScoreCtrol();

    //implementation of virtual event handlers

    virtual void on_debug_show_source_score();

    virtual void on_debug_show_midi_events();

    virtual void on_end_of_playback();

protected:

    //virtual pure methods defined in this class

    virtual ImoScore* prepare_aux_score(int nButton)=0;

    virtual bool are_answer_buttons_allowed_for_playing();

    virtual bool is_play_again_message_allowed();

    virtual bool remove_problem_text_when_displaying_solution();

    //implementation of some virtual methods

    virtual void play(bool fVisualTracking=true);

    void play_specific_sound(int nButton);

    void display_solution();

    void display_problem_score();

    void delete_scores();

    void stop_sounds();

        // member variables

    ScorePlayer* m_pPlayer;

    ImoScore*   m_pProblemScore;    //score with the problem

	ImoScore*   m_pSolutionScore;	//if not NULL, score with the solution. If NULL

                                    //   problem score will be used as solution score

    ImoScore*   m_pAuxScore;        //score to play user selected buttons

    int         m_nPlayMM;          //metronome setting to play scores

};

////---------------------------------------------------------------------------------------

//// Abstract class to create exercises to compare two Midi pitches

//class CompareMidiCtrol : public CompareCtrol

//{

//public:

//    CompareMidiCtrol(long dynId, ApplicationScope& appScope, DocumentCanvas* pCanvas);

//    virtual ~CompareMidiCtrol();

//

//    // event handlers

//    void OnTimerEvent(wxTimerEvent& WXUNUSED(event));

//

//    //implementation of virtual event handlers

//    virtual void on_debug_show_source_score() {}

//    virtual void on_debug_show_midi_events() {}

//

//protected:

//    //implementation of some virtual methods

//    virtual void play();

//    void play_specific_sound(int nButton) {}

//    void display_solution();

//    void display_problem_score();

//    void delete_scores() {}

//    void stop_sounds();

//

//protected:

//    void PlaySound(int iSound);

//

//

//        // member variables

//

//    MidiPitch            m_mpPitch[2];

//    int                 m_nChannel[2];

//    int                 m_nInstr[2];

//    long                m_nTimeIntval[2];   //interval between first and second pitch

//    bool                m_fStopPrev;        //stop previous pitch when sounding the next pitch

//

//    wxTimer             m_oTimer;           //timer to control sounds' duration

//    int                 m_nNowPlaying;      //pitch number being played or -1

//};

//---------------------------------------------------------------------------------------

// Abstract class for any kind of exercise using the score editor

class FullEditorCtrol : public EBookCtrol

{

protected:

    ExerciseOptions* m_pConstrains;

    //the scores

    ImoScore* m_pProblemScore;  //(opt) the problem (aural training)

    ImoScore* m_pContextScore;  //(opt) to play before problem, to create pitch/tonality context

    ImoScore* m_pUserScore;     //the one to be displayed and edited by student

    //score player and its settings

    ScorePlayer* m_pPlayer;

    int m_nPlayMM;              //metronome setting to play scores

    int m_midiVoice;            //instrument to use for playing scores

    //display control variables

    ImoScore*           m_pUserScoreToPlay;

    ImoScore*           m_pProblemScoreToPlay;

    ProblemDisplayer*   m_pDisplay;

    //action buttons

    HyperlinkCtrl*  m_pPlayProblem;     //"Play problem again" button

    HyperlinkCtrl*  m_pPlayUserScore;   //"Play my solution" button

    HyperlinkCtrl*  m_pNewProblem;      //"New problem" link

    HyperlinkCtrl*  m_pDoneButton;      //"Done" link

    //other

    int m_numTimesProblemPlayed;

    //pre-translated strings for button labels

    string m_label_new_problem;

    string m_label_play_problem;

    string m_label_done;

    string m_label_play_user_score;

    string m_label_stop_playing;

    FullEditorCtrol(long dynId, ApplicationScope& appScope, DocumentWindow* pCanvas);

public:

    virtual ~FullEditorCtrol();

    //implementation of virtual pure in parent EBookCtrol

    virtual void on_debug_show_source_score();

    virtual void on_debug_show_midi_events();

    //specific

    //event handlers. No need to implement in derived classes

    virtual void on_end_of_playback();

protected:

    //virtual methods to be implemented by derived classes

    virtual wxString generate_new_problem()=0;

    virtual void do_correct_exercise()=0;

    virtual void delete_specific_scores()=0;

    //overridable, for changing default exercise layout

    ImoStyle* m_pLinksSpacerStyle;

    virtual void layout_exercise();

    virtual void add_settings_goback_and_debug_links(ImoParagraph* pContainer,

                                                     ImoStyle* pSpacerStyle=NULL);

    virtual void add_new_problem_link(ImoParagraph* pContainer, ImoStyle* pSpacerStyle=NULL);

    virtual void add_play_problem_link(ImoParagraph* pContainer, ImoStyle* pSpacerStyle=NULL);

    virtual void add_done_link(ImoParagraph* pContainer, ImoStyle* pSpacerStyle=NULL);

    virtual void add_play_solution_link(ImoParagraph* pContainer, ImoStyle* pSpacerStyle=NULL);

    virtual void add_optional_content_block_1() {}

    virtual void add_optional_content_block_2() {}

    //methods that, normally, it is not necessary to override in derived classes

    virtual void process_event(int event);

    virtual void new_problem();

    virtual void initial_play_of_problem();

    virtual void reset_exercise();

    virtual void correct_exercise();

    virtual void create_problem_display_box(ImoContent* pWrapper, ImoStyle* pStyle=NULL);

    virtual void enable_links_for_current_state();

    void create_controls();

    void display_user_score();

    void enable_edition();

    void disable_edition();

    void play_or_stop_user_score();

    void play_or_stop_problem(bool fDoCountOff=false);

    void do_play_problem(bool fDoCountOff);

    void stop_sounds();

    void delete_scores();

    void mover_cursor_to_end();

    void change_state(int newState);

    //events

    enum {

        k_click_new_problem=0,

        k_click_play_or_stop_problem,

        k_click_done,

        k_click_play_or_stop_user_score,

        k_end_of_playback,

        //

        k_first_unused_event,

    };

    //exercise states

    enum {

        k_state_start=0,            //user has entered in exercise page

        k_state_playing_problem,    //program is playing the problem score

        k_state_ready,              //user can start solving the problem

        k_state_solution,           //solution is displayed

        k_state_playing_user,       //program is playing user solution

        k_state_replaying_problem,  //program is playing again problem score

        k_state_first_unused

    };

    //helper

//    inline bool is_solution_displayed() { return m_fSolutionDisplayed; }

    inline bool is_theory_mode() {

        return (static_cast<ExerciseOptions*>( m_pBaseConstrains ))->is_theory_mode();

    }

    //wrappers for event handlers

    static void on_new_problem(void* pThis, SpEventInfo pEvent);

    static void on_play_problem(void* pThis, SpEventInfo pEvent);

    static void on_play_user_score(void* pThis, SpEventInfo pEvent);

    static void on_correct_exercise(void* pThis, SpEventInfo pEvent);

    static void on_settings(void* pThis, SpEventInfo pEvent);

    static void on_see_source_score(void* pThis, SpEventInfo pEvent);

    static void on_see_midi_events(void* pThis, SpEventInfo pEvent);

    static void on_go_back_event(void* pThis, SpEventInfo pEvent);

};

}   //namespace lenmus

#endif  // __LENMUS_EXERCISE_CTROL_H__