← Back to branch summary

~s-cecilio/lenmus/v5.3

« back to all changes in this revision

Viewing changes to src/exercises/Constrains.h

  • Committer: cecilios
  • Date: 2007-05-19 11:39:03 UTC
  • Revision ID: svn-v4:2587a929-2f0e-0410-ae78-fe6f687d5efe:trunk:236

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/exercises/Constrains.h
 
1
//--------------------------------------------------------------------------------------
 
2
//    LenMus Phonascus: The teacher of music
 
3
//    Copyright (c) 2002-2007 Cecilio Salmeron
 
4
//
 
5
//    This program is free software; you can redistribute it and/or modify it under the 
 
6
//    terms of the GNU General Public License as published by the Free Software Foundation;
 
7
//    either version 2 of the License, or (at your option) any later version.
 
8
//
 
9
//    This program is distributed in the hope that it will be useful, but WITHOUT ANY 
 
10
//    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A 
 
11
//    PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 
12
//
 
13
//    You should have received a copy of the GNU General Public License along with this 
 
14
//    program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, 
 
15
//    Fifth Floor, Boston, MA  02110-1301, USA.
 
16
//
 
17
//    For any comment, suggestion or feature request, please contact the manager of 
 
18
//    the project at cecilios@users.sourceforge.net
 
19
//
 
20
//-------------------------------------------------------------------------------------
 
21
/*! @file Constrains.h
 
22
    @brief Header file for Constrain derived classes
 
23
    @ingroup generators
 
24
*/
 
25
#ifdef __GNUG__
 
26
// #pragma interface
 
27
#endif
 
28
 
 
29
#ifndef __CONSTRAINS_H__        //to avoid nested includes
 
30
#define __CONSTRAINS_H__
 
31
 
 
32
// For compilers that support precompilation, includes "wx/wx.h".
 
33
#include "wx/wxprec.h"
 
34
 
 
35
#ifdef __BORLANDC__
 
36
#pragma hdrstop
 
37
#endif
 
38
 
 
39
#ifndef WX_PRECOMP
 
40
#include "wx/wx.h"
 
41
#endif
 
42
 
 
43
#include "../score/Score.h"
 
44
 
 
45
 
 
46
enum EIntervalName              // name of the intervals considered in exercises
 
47
{
 
48
    ein_1 = 0,      // unison       // must start with 0. Used as index for arrays
 
49
    ein_2min,
 
50
    ein_2maj,
 
51
    ein_3min,
 
52
    ein_3maj,
 
53
    ein_4,
 
54
    ein_4aug,
 
55
    ein_5,
 
56
    ein_6min,
 
57
    ein_6maj,
 
58
    ein_7min,
 
59
    ein_7maj,
 
60
    ein_8,
 
61
    ein_9min,
 
62
    ein_9maj,
 
63
    ein_10min,
 
64
    ein_10maj,
 
65
    ein_11,
 
66
    ein_11aug,
 
67
    ein_12,
 
68
    ein_13min,
 
69
    ein_13maj,
 
70
    ein_14min,
 
71
    ein_14maj,
 
72
    ein_2oct,
 
73
    ein_Max_Item        //Must be the last one. Just to know how many items
 
74
};
 
75
 
 
76
#define lmNUM_INTVALS  ein_Max_Item     //num intervals considered in constraints
 
77
 
 
78
//----------------------------------------------------------------------------------------
 
79
 
 
80
class lmClefConstrain
 
81
{
 
82
public:
 
83
    lmClefConstrain();
 
84
    ~lmClefConstrain() {}
 
85
    bool IsValid(EClefType nClef) { return m_fValidClefs[nClef-lmMIN_CLEF]; }
 
86
    void SetValid(EClefType nClef, bool fValid) { m_fValidClefs[nClef-lmMIN_CLEF] = fValid; }
 
87
 
 
88
    //pitch scope
 
89
    wxString GetLowerPitch(EClefType nClef)  { return m_aLowerPitch[nClef-lmMIN_CLEF]; }
 
90
    wxString GetUpperPitch(EClefType nClef)  { return m_aUpperPitch[nClef-lmMIN_CLEF]; }
 
91
    void SetLowerPitch(EClefType nClef, wxString sPitch)  {
 
92
                m_aLowerPitch[nClef-lmMIN_CLEF] = sPitch;
 
93
            }
 
94
    void SetUpperPitch(EClefType nClef, wxString sPitch)  {
 
95
                m_aUpperPitch[nClef-lmMIN_CLEF] = sPitch;
 
96
            }
 
97
 
 
98
 
 
99
private:
 
100
    bool m_fValidClefs[lmMAX_CLEF - lmMIN_CLEF + 1];
 
101
    wxString m_aLowerPitch[lmMAX_CLEF - lmMIN_CLEF + 1];
 
102
    wxString m_aUpperPitch[lmMAX_CLEF - lmMIN_CLEF + 1];
 
103
};
 
104
 
 
105
//----------------------------------------------------------------------------------------
 
106
 
 
107
class lmKeyConstrains
 
108
{
 
109
public:
 
110
    lmKeyConstrains();
 
111
    ~lmKeyConstrains() {}
 
112
    bool IsValid(EKeySignatures nKey) { return m_fValidKeys[nKey-lmMIN_KEY]; }
 
113
    void SetValid(EKeySignatures nKey, bool fValid) { m_fValidKeys[nKey-lmMIN_KEY] = fValid; }
 
114
 
 
115
private:
 
116
    bool m_fValidKeys[lmMAX_KEY - lmMIN_KEY + 1];
 
117
};
 
118
 
 
119
//----------------------------------------------------------------------------------------
 
120
 
 
121
class lmTimeSignConstrains
 
122
{
 
123
public:
 
124
    lmTimeSignConstrains();
 
125
    ~lmTimeSignConstrains() {}
 
126
    bool IsValid(ETimeSignature nTime) { return m_fValidTimes[nTime-lmMIN_TIME_SIGN]; }
 
127
    void SetValid(ETimeSignature nTime, bool fValid) {
 
128
            m_fValidTimes[nTime-lmMIN_TIME_SIGN] = fValid; 
 
129
        }
 
130
    bool SetConstrains(wxString sTimeSigns);
 
131
 
 
132
private:
 
133
    bool m_fValidTimes[lmMAX_TIME_SIGN - lmMIN_TIME_SIGN + 1];
 
134
};
 
135
 
 
136
// lmTheoIntervalsConstrains -------------------------------------------------------------
 
137
 
 
138
enum EProblemTheoIntervals
 
139
{
 
140
    ePT_DeduceInterval = 0,         //WARNING: the enum values are used as indexes
 
141
    ePT_BuildInterval,              // in DlgCfgTheoIntervals. Do not alter
 
142
    ePT_Both                        // neither order nor values. Must start in 0
 
143
};
 
144
 
 
145
 
 
146
class lmTheoIntervalsConstrains //: public ProblemConstrains
 
147
{
 
148
public:
 
149
    lmTheoIntervalsConstrains();
 
150
    ~lmTheoIntervalsConstrains() {}
 
151
 
 
152
    bool IsValidClef(EClefType nClef) { return m_oClefs.IsValid(nClef); }
 
153
    void SetClef(EClefType nClef, bool fValid) { m_oClefs.SetValid(nClef, fValid); }
 
154
 
 
155
    EProblemTheoIntervals GetProblemType() { return m_nProblemType; }
 
156
    void SetProblemType(EProblemTheoIntervals nType) { m_nProblemType = nType; }
 
157
 
 
158
    bool GetAccidentals() { return m_fAccidentals; }
 
159
    void SetAccidentals(bool fValue) { m_fAccidentals = fValue; }
 
160
 
 
161
    bool GetDoubleAccidentals() { return m_fDoubleAccidentals; }
 
162
    void SetDoubleAccidentals(bool fValue) { m_fDoubleAccidentals = fValue; }
 
163
 
 
164
    lmClefConstrain* GetClefConstrains() { return &m_oClefs; }
 
165
 
 
166
    void SaveSettings();
 
167
 
 
168
 
 
169
private:
 
170
    void LoadSettings();
 
171
 
 
172
    lmClefConstrain         m_oClefs;
 
173
    EProblemTheoIntervals   m_nProblemType;
 
174
    bool                    m_fAccidentals;             //allow accidentals
 
175
    bool                    m_fDoubleAccidentals;       //allow double accidentals
 
176
 
 
177
};
 
178
 
 
179
 
 
180
/*! @class lmScoreCtrolOptions
 
181
    @brief Options for lmScoreCtrol control
 
182
*/
 
183
class lmScoreCtrolOptions
 
184
{
 
185
public:
 
186
    lmScoreCtrolOptions() {
 
187
            //default values
 
188
            fPlayCtrol = false;
 
189
            fSolfaCtrol = false;
 
190
            fMeasuresCtrol = false;
 
191
            fBorder = false;
 
192
            fMusicBorder = false;
 
193
            sPlayLabel = _("Play");
 
194
            sStopPlayLabel = _("Stop");
 
195
            sSolfaLabel = _("Read");
 
196
            sStopSolfaLabel = _("Stop");
 
197
            sMeasuresLabel = _("Measure %d");
 
198
            sStopMeasureLabel = _("Stop %d");
 
199
            rScale = 1.0;
 
200
            m_nMM = 0;
 
201
        }
 
202
 
 
203
    ~lmScoreCtrolOptions() {}
 
204
 
 
205
    void SetControlPlay(bool fValue, wxString sLabels = _T(""))
 
206
        { 
 
207
            fPlayCtrol = fValue;
 
208
            if (sLabels != _T(""))
 
209
                SetLabels(sLabels, &sPlayLabel, &sStopPlayLabel);
 
210
        }
 
211
    void SetControlSolfa(bool fValue, wxString sLabels = _T(""))
 
212
        { 
 
213
            fSolfaCtrol = fValue;
 
214
            if (sLabels != _T(""))
 
215
                SetLabels(sLabels, &sSolfaLabel, &sStopSolfaLabel);
 
216
        }
 
217
    void SetControlMeasures(bool fValue, wxString sLabels = _T(""))
 
218
        { 
 
219
            fMeasuresCtrol = fValue;
 
220
            if (sLabels != _T(""))
 
221
                SetLabels(sLabels, &sMeasuresLabel, &sStopMeasureLabel);
 
222
        }
 
223
 
 
224
    void SetMetronomeMM(long nValue) { m_nMM = nValue; }
 
225
    long GetMetronomeMM() { return m_nMM; }
 
226
 
 
227
    
 
228
    bool        fPlayCtrol;             //Instert "Play" link
 
229
    wxString    sPlayLabel;             //label for "Play" link
 
230
    wxString    sStopPlayLabel;         //label for "Stop playing" link
 
231
 
 
232
    bool        fSolfaCtrol;            //insert a "Sol-fa" link
 
233
    wxString    sSolfaLabel;            //label for "Sol-fa" link
 
234
    wxString    sStopSolfaLabel;        //label for "Stop sol-fa" link
 
235
 
 
236
    bool        fMeasuresCtrol;         //insert "play-measure" links
 
237
    wxString    sMeasuresLabel;
 
238
    wxString    sStopMeasureLabel;
 
239
 
 
240
    bool        fBorder;                // border around control
 
241
    bool        fMusicBorder;           // border around music
 
242
 
 
243
    double      rScale;
 
244
 
 
245
private:
 
246
    void SetLabels(wxString& sLabel, wxString* pStart, wxString* pStop);
 
247
 
 
248
    long        m_nMM;                  // metronome setting
 
249
 
 
250
};
 
251
 
 
252
 
 
253
/*! @class lmMusicReadingCtrolOptions
 
254
    @brief Options for lmTheoMusicReadingCtrol control
 
255
*/
 
256
class lmMusicReadingCtrolOptions
 
257
{
 
258
public:
 
259
    lmMusicReadingCtrolOptions() {
 
260
            //default values
 
261
            fPlayCtrol = false;
 
262
            fSolfaCtrol = false;
 
263
            fBorder = false;
 
264
            fGoBackLink = false;
 
265
            fSettingsLink = false;
 
266
            sPlayLabel = _("Play");
 
267
            sStopPlayLabel = _("Stop");
 
268
            sSolfaLabel = _("Read");
 
269
            sStopSolfaLabel = _("Stop");
 
270
        }
 
271
 
 
272
    ~lmMusicReadingCtrolOptions() {}
 
273
    void SetControlPlay(bool fValue, wxString sLabels = _T(""))
 
274
        { 
 
275
            fPlayCtrol = fValue;
 
276
            if (sLabels != _T(""))
 
277
                SetLabels(sLabels, &sPlayLabel, &sStopPlayLabel);
 
278
        }
 
279
    void SetControlSolfa(bool fValue, wxString sLabels = _T(""))
 
280
        { 
 
281
            fSolfaCtrol = fValue;
 
282
            if (sLabels != _T(""))
 
283
                SetLabels(sLabels, &sSolfaLabel, &sStopSolfaLabel);
 
284
        }
 
285
    void SetControlSettings(bool fValue, wxString sKey =_T(""))
 
286
        {
 
287
            fSettingsLink = fValue;
 
288
            sSettingsKey = sKey;
 
289
        }
 
290
 
 
291
    void SetGoBackURL(wxString sURL) { fGoBackLink = true; sGoBackURL = sURL; }
 
292
 
 
293
 
 
294
    bool        fPlayCtrol;             //Instert "Play" link
 
295
    wxString    sPlayLabel;             //label for "Play" link
 
296
    wxString    sStopPlayLabel;         //label for "Stop playing" link
 
297
 
 
298
    bool        fSolfaCtrol;            //insert a "Sol-fa" link
 
299
    wxString    sSolfaLabel;            //label for "Sol-fa" link
 
300
    wxString    sStopSolfaLabel;        //label for "Stop sol-fa" link
 
301
 
 
302
    bool        fBorder;
 
303
    bool        fGoBackLink;            // insert a "Go back to theory" link
 
304
    wxString    sGoBackURL;             //URL for "Go back" link
 
305
 
 
306
    bool        fSettingsLink;          // insert the settings link
 
307
    wxString    sSettingsKey;           // key for saving the user settings
 
308
 
 
309
private:
 
310
    void SetLabels(wxString& sLabel, wxString* pStart, wxString* pStop);
 
311
 
 
312
 
 
313
};
 
314
 
 
315
 
 
316
 
 
317
// lmTheoScalesConstrains -------------------------------------------------------------
 
318
 
 
319
enum EProblemTheoScales
 
320
{
 
321
    ePTS_DeduceScale = 0,
 
322
    ePTS_BuildScale,
 
323
    ePTS_Both
 
324
};
 
325
 
 
326
 
 
327
class lmTheoScalesConstrains
 
328
{
 
329
public:
 
330
    lmTheoScalesConstrains() {
 
331
            m_fCtrolKeySignature = false;
 
332
            m_fDrawWithoutKeySignature = true;
 
333
            m_fMajor = false;
 
334
            m_fMinor = false;
 
335
            m_nProblemType = ePTS_Both;
 
336
        }
 
337
    ~lmTheoScalesConstrains() {}
 
338
 
 
339
    bool IsValidClef(EClefType nClef) { return m_oClefs.IsValid(nClef); }
 
340
    void SetClef(EClefType nClef, bool fValid) { m_oClefs.SetValid(nClef, fValid); }
 
341
    lmClefConstrain* GetClefConstrains() { return &m_oClefs; }
 
342
 
 
343
    EProblemTheoScales GetProblemType() { return m_nProblemType; }
 
344
    void SetProblemType(EProblemTheoScales nType) { m_nProblemType = nType; }
 
345
 
 
346
    void SetMajorType(bool fValue) { m_fMajor = fValue; }
 
347
    bool MajorType() { return m_fMajor; }
 
348
    void SetMinorType(bool fValue) { m_fMinor = fValue; }
 
349
    bool MinorType() { return m_fMinor; }
 
350
    void SetCtrolKeySignature(bool fValue) { m_fCtrolKeySignature = fValue; }
 
351
    bool CtrolKeySignature() { return m_fCtrolKeySignature; }
 
352
    bool DrawWithoutKeySignature() { return m_fDrawWithoutKeySignature; }
 
353
 
 
354
private:
 
355
    bool                m_fCtrolKeySignature;
 
356
    bool                m_fDrawWithoutKeySignature;
 
357
    bool                m_fMajor;
 
358
    bool                m_fMinor;
 
359
    lmClefConstrain     m_oClefs;
 
360
    EProblemTheoScales  m_nProblemType;
 
361
 
 
362
};
 
363
 
 
364
#endif  // __CONSTRAINS_H__
 
365