]> git.donarmstrong.com Git - lilypond.git/blob - lily/scale.cc
Doc-es: Update of Input.
[lilypond.git] / lily / scale.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 2006--2009 Han-Wen Nienhuys <hanwen@lilypond.org>
5       2007--2008 Rune Zedeler
6       2008       Joe Neeman <joeneeman@gmail.com>
7
8   LilyPond is free software: you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation, either version 3 of the License, or
11   (at your option) any later version.
12
13   LilyPond is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "scale.hh"
23
24 #include "ly-smobs.icc"
25
26 /*
27   todo: put string <-> pitch here too.
28
29 */
30 LY_DEFINE (ly_make_scale, "ly:make-scale",
31            1, 0, 0, (SCM steps),
32            "Create a scale."
33            "  The argument is a vector of rational numbers, each of which"
34            " represents the number of 200 cent tones of a pitch above the"
35            " tonic.")
36 {
37   bool type_ok = scm_is_vector (steps);
38
39   vector<Rational> tones; 
40   if (type_ok)
41     {
42       int len = scm_c_vector_length (steps);
43       for (int i = 0 ; i < len; i++)
44         {
45           SCM step = scm_c_vector_ref (steps, i);
46           type_ok = type_ok && scm_is_rational (step);
47           if (type_ok)
48             {
49               Rational from_c (scm_to_int (scm_numerator (step)),
50                                scm_to_int (scm_denominator (step)));
51               tones.push_back (from_c);
52             }
53         }
54     }
55   
56   
57   SCM_ASSERT_TYPE (type_ok, steps, SCM_ARG1, __FUNCTION__, "vector of rational");
58
59   Scale *s = new Scale (tones);
60
61   SCM retval =  s->self_scm ();
62   s->unprotect ();
63   
64   return retval;
65 }
66
67 LY_DEFINE (ly_default_scale, "ly:default-scale",
68            0, 0, 0, (),
69            "Get the global default scale.")
70 {
71   return default_global_scale
72     ? default_global_scale->self_scm ()
73     : SCM_BOOL_F;
74 }
75
76
77 Scale * default_global_scale = 0;
78
79 LY_DEFINE (ly_set_default_scale, "ly:set-default-scale",
80            1, 0, 0, (SCM scale),
81            "Set the global default scale. This determines the tuning of"
82            " pitches with no accidentals or key signatures.  The first"
83            " pitch is C. Alterations are calculated relative to this"
84            " scale.  The number of pitches in this scale determines the"
85            " number of scale steps that make up an octave.  Usually the"
86            " 7-note major scale.")
87 {
88   LY_ASSERT_SMOB (Scale, scale, 1);
89
90   Scale *s = Scale::unsmob (scale);
91   if (default_global_scale)
92     default_global_scale->unprotect ();
93   default_global_scale = s;
94   s->protect ();
95   
96   return SCM_UNSPECIFIED;
97 }
98
99 int
100 Scale::step_count () const
101 {
102   return step_tones_.size ();
103 }
104
105 Rational
106 Scale::tones_at_step (int step, int octave) const
107 {
108   int normalized_step = normalize_step (step);
109
110   octave += (step - normalized_step) / step_count ();
111
112   // There are 6 tones in an octave.
113   return step_tones_[normalized_step] + Rational (octave*6);
114 }
115
116 Rational
117 Scale::step_size (int step) const
118 {
119   int normalized_step = normalize_step (step);
120
121   // Wrap around if we are asked for the final note of the
122   // scale (6 is the number of tones of the octave above the
123   // first note).
124   if (normalized_step + 1 == step_count ())
125     return Rational(6) - step_tones_[normalized_step];
126
127   return step_tones_[normalized_step + 1] - step_tones_[normalized_step];
128 }
129
130 int
131 Scale::normalize_step (int step) const
132 {
133   int ret = step % step_count ();
134   if (ret < 0)
135     ret += step_count ();
136
137   return ret;
138 }
139
140 int
141 Scale::print_smob (SCM /* x */,
142                    SCM port,
143                    scm_print_state *)
144 {
145   scm_puts ("#<Scale>", port); 
146   return 1;
147 }
148
149 SCM
150 Scale::mark_smob (SCM)
151 {
152   return SCM_UNSPECIFIED;
153 }
154
155 Scale::Scale (vector<Rational> const &tones)
156 {
157   step_tones_ = tones;
158
159   smobify_self ();
160 }
161
162 Scale::Scale (Scale const &src)
163 {
164   step_tones_ = src.step_tones_;
165   smobify_self ();
166 }
167
168
169 Scale::~Scale ()
170 {
171 }
172
173 IMPLEMENT_SMOBS (Scale);
174 IMPLEMENT_DEFAULT_EQUAL_P (Scale);