def make_spacing_vector(
basic_distance,
minimum_distance,
padding,
stretchability,
):
r'''Makes spacing vector.
::
>>> vector = schemetools.make_spacing_vector(0, 0, 12, 0)
Use to set paper block spacing attributes:
::
>>> staff = Staff("c'8 d'8 e'8 f'8")
>>> lilypond_file = lilypondfiletools.make_basic_lilypond_file(staff)
>>> spacing_vector = schemetools.make_spacing_vector(0, 0, 12, 0)
>>> lilypond_file.paper_block.system_system_spacing = spacing_vector
.. doctest::
>>> print(format(lilypond_file)) # doctest: +SKIP
% Abjad revision 4229
% 2011-04-07 15:19
\version "2.13.44"
\language "english"
\paper {
system-system-spacing = #'(
(basic-distance . 0) (minimum-distance . 0) (padding . 12) (stretchability . 0))
}
\score {
\new Staff {
c'8
d'8
e'8
f'8
}
}
Returns scheme vector.
'''
from abjad.tools import schemetools
return schemetools.SchemeVector(
schemetools.SchemePair('basic-distance', basic_distance),
schemetools.SchemePair('minimum-distance', minimum_distance),
schemetools.SchemePair('padding', padding),
schemetools.SchemePair('stretchability', stretchability))
def __init__(
self,
basic_distance=0,
minimum_distance=0,
padding=12,
stretchability=0,
):
from abjad.tools import schemetools
pairs = [
schemetools.SchemePair(('basic-distance', basic_distance)),
schemetools.SchemePair(('minimum-distance', minimum_distance)),
schemetools.SchemePair(('padding', padding)),
schemetools.SchemePair(('stretchability', stretchability)),
]
return SchemeVector.__init__(self, pairs)
def translate(self, offset_pair):
r'''LilyPond ``translate`` markup command.
.. container:: example
::
>>> markup = Markup('Allegro assai')
>>> markup = markup.translate((2, 1))
::
>>> print(format(markup))
\markup {
\translate
#'(2 . 1)
"Allegro assai"
}
::
>>> show(markup) # doctest: +SKIP
Returns new markup.
'''
from abjad.tools import markuptools
contents = self._parse_markup_command_argument(self)
offset_pair = schemetools.SchemePair(offset_pair)
command = markuptools.MarkupCommand(
'translate',
offset_pair,
contents,
)
return new(self, contents=command)
def format_lilypond_value(expr):
r'''Formats LilyPond `expr` according to Scheme formatting
conventions.
Returns string.
'''
from abjad.tools import schemetools
if '_lilypond_format' in dir(expr) and not isinstance(expr, str):
pass
elif expr in (True, False):
expr = schemetools.Scheme(expr)
elif expr in (Up, Down, Left, Right, Center):
expr = schemetools.Scheme(repr(expr).lower())
elif isinstance(expr, int) or isinstance(expr, float):
expr = schemetools.Scheme(expr)
elif expr in LilyPondFormatManager.lilypond_color_constants:
expr = schemetools.Scheme(expr)
elif isinstance(expr, str) and '::' in expr:
expr = schemetools.Scheme(expr)
elif isinstance(expr, tuple) and len(expr) == 2:
expr = schemetools.SchemePair(expr[0], expr[1])
elif isinstance(expr, str) and ' ' not in expr:
expr = schemetools.Scheme(expr, quoting="'")
elif isinstance(expr, str) and ' ' in expr:
expr = schemetools.Scheme(expr)
else:
expr = schemetools.Scheme(expr, quoting="'")
return format(expr, 'lilypond')
def __call__(self, expr):
r'''Calls handler on `expr`.
Returns none.
'''
assert self.dynamics_talea, repr(self.dynamics_talea)
groups = []
classes = (scoretools.Note, scoretools.Chord)
for i, group in enumerate(iterate(expr).by_run(classes)):
spanner = spannertools.TextSpanner()
attach(spanner, group)
override(spanner).text_spanner.dash_fraction = 1
dynamic_string = self.dynamics_talea[i]
dynamicup = markuptools.Markup([
markuptools.MarkupCommand('dynamic', dynamic_string),
markuptools.MarkupCommand('hspace', 0.75)])
override(spanner).text_spanner.bound_details__left__text = \
dynamicup
nib_markup = markuptools.Markup(
markuptools.MarkupCommand(
'draw-line', schemetools.SchemePair(0, 1)))
override(spanner).text_spanner.bound_details__right__text = \
nib_markup
override(spanner).text_spanner.bound_details__right__padding = \
-0.2
override(spanner).text_spanner.bound_details__left__stencil_align_dir_y = 0
return groups
def scale(self, factor_pair):
r'''LilyPond ``\scale`` markup command.
.. container:: example
::
>>> markup = Markup('Allegro assai')
>>> markup = markup.scale((0.75, 0.75))
::
>>> print(format(markup))
\markup {
\scale
#'(0.75 . 0.75)
"Allegro assai"
}
::
>>> show(markup) # doctest: +SKIP
Returns new markup.
'''
from abjad.tools import markuptools
contents = self._parse_markup_command_argument(self)
factor_pair = schemetools.SchemePair(factor_pair)
command = markuptools.MarkupCommand(
'scale',
factor_pair,
contents,
)
return new(self, contents=command)
def _make_class_name_markup(rhythm_maker):
class_ = type(rhythm_maker)
string = class_.__name__
string = stringtools.capitalize_start(string)
pair = schemetools.SchemePair('font-name', 'Times')
command = markuptools.MarkupCommand('override', pair, string)
command = markuptools.MarkupCommand('fontsize', 4.5, command)
markup = markuptools.Markup(command)
return markup
def p_list__L_PAREN__data__datum__PERIOD__datum__R_PAREN(self, p):
r'''list : L_PAREN data datum PERIOD datum R_PAREN
'''
p.slice[0].cursor_end = p.slice[-1].cursor_end
result = p[2] + [p[3]] + [p[5]]
if len(result) == 2:
p[0] = schemetools.SchemePair(*result)
else:
p[0] = schemetools.Scheme(*result)
self.expression_depth -= 1
def __init__(self, *args, **kwargs):
from abjad.tools import schemetools
args_as_pairs = []
for arg in args:
if not isinstance(arg, (tuple, schemetools.SchemePair)):
message = 'must be Python pair or Scheme pair: "%s".'
raise TypeError(message % arg)
arg_as_pair = schemetools.SchemePair(*arg)
args_as_pairs.append(arg_as_pair)
Scheme.__init__(self, *args_as_pairs, **{'quoting': "'"})
def _make_configuration_markup(rhythm_maker):
string = format(rhythm_maker, 'storage')
string = string.replace('rhythmmakertools.', '')
lines = string.split('\n')
command = markuptools.MarkupCommand('column', lines)
command.force_quotes = True
pair = schemetools.SchemePair('font-name', 'Courier')
command = markuptools.MarkupCommand('override', pair, command)
markup = markuptools.Markup(command, direction=Up)
return markup
def make_dynamic_spanner_below_with_nib_at_right(dynamic_text):
r'''Makes dynamic spanner below with nib at right.
.. container:: example
::
>>> staff = Staff("c'8 d'8 e'8 f'8")
>>> spanner = spannertools.make_dynamic_spanner_below_with_nib_at_right('mp')
>>> attach(spanner, staff[:])
>>> show(staff) # doctest: +SKIP
.. doctest::
>>> print(format(staff))
\new Staff {
\override TextSpanner.bound-details.left.text = \markup { \dynamic { mp } }
\override TextSpanner.bound-details.right-broken.text = ##f
\override TextSpanner.bound-details.right.text = \markup {
\draw-line
#'(0 . 1)
}
\override TextSpanner.dash-fraction = #1
\override TextSpanner.direction = #down
c'8 \startTextSpan
d'8
e'8
f'8 \stopTextSpan
\revert TextSpanner.bound-details
\revert TextSpanner.dash-fraction
\revert TextSpanner.direction
}
Returns text spanner.
'''
from abjad.tools import spannertools
text_spanner = spannertools.TextSpanner()
string = r'\dynamic {{ {} }}'.format(dynamic_text)
left_markup = markuptools.Markup(string)
pair = schemetools.SchemePair(0, 1)
markup_command = markuptools.MarkupCommand('draw-line', pair)
right_markup = markuptools.Markup(markup_command)
grob = override(text_spanner).text_spanner
grob.bound_details__left__text = left_markup
grob.bound_details__right__text = right_markup
grob.bound_details__right_broken__text = False
grob.dash_fraction = 1
grob.direction = Down
return text_spanner
def _to_markup(self, class_):
instance = class_(**self.arguments)
string = format(instance, 'storage')
string = string.replace('rhythmmakertools.', '')
lines = string.split('\n')
command = markuptools.MarkupCommand('column', lines)
command.force_quotes = True
pair = schemetools.SchemePair('font-name', 'Courier')
command = markuptools.MarkupCommand('override', pair, command)
markup = markuptools.Markup(command, direction=Up)
return markup
def __call__(self):
'''Calls woodwind fingering.
Returns markup command.
'''
key_groups_as_scheme = []
cc_scheme_pair = schemetools.SchemePair('cc', self._center_column)
key_groups_as_scheme.append(cc_scheme_pair)
lh_scheme_pair = schemetools.SchemePair('lh', self._left_hand)
key_groups_as_scheme.append(lh_scheme_pair)
rh_scheme_pair = schemetools.SchemePair('rh', self._right_hand)
key_groups_as_scheme.append(rh_scheme_pair)
key_groups_as_scheme = schemetools.Scheme(key_groups_as_scheme[:],
quoting="'")
instrument_as_scheme = schemetools.Scheme(self._instrument_name,
quoting="'")
return markuptools.MarkupCommand(
'woodwind-diagram',
instrument_as_scheme,
key_groups_as_scheme,
)
def __init__(self, value=None):
from abjad.tools import schemetools
value = value or []
pairs = []
for item in value:
if isinstance(item, tuple):
pair = schemetools.SchemePair(item)
elif isinstance(item, schemetools.SchemePair):
pair = item
else:
message = 'must be Python pair or Scheme pair: {!r}.'
message = message.format(item)
raise TypeError(message)
pairs.append(pair)
Scheme.__init__(self, value=pairs, quoting="'")
def _make_score_number_markup(
configuration_number,
score_number,
):
assert mathtools.is_nonnegative_integer(configuration_number)
assert mathtools.is_nonnegative_integer(score_number)
number_string = '{}-{}'.format(
configuration_number,
score_number,
)
command = markuptools.MarkupCommand('fontsize', 2, number_string)
command = markuptools.MarkupCommand('italic', command)
command = markuptools.MarkupCommand('box', command)
pair = schemetools.SchemePair('box-padding', 0.75)
command = markuptools.MarkupCommand('override', pair, command)
width = 9
command = markuptools.MarkupCommand('hcenter-in', width, command)
markup = markuptools.Markup(command)
return markup
def override(self, new_property):
r'''LilyPond ``\override`` markup command.
.. container:: example
::
>>> markup = Markup('Allegro assai')
>>> markup = markup.parenthesize()
>>> markup = markup.override(('padding', 0.75))
::
>>> f(markup)
\markup {
\override
#'(padding . 0.75)
\parenthesize
"Allegro assai"
}
::
>>> show(markup) # doctest: +SKIP
Returns new markup.
'''
from abjad.tools import markuptools
contents = self._parse_markup_command_argument(self)
new_property = schemetools.SchemePair(new_property)
command = markuptools.MarkupCommand(
'override',
new_property,
contents,
)
return new(self, contents=command)
def make_colored_text_spanner_with_nibs():
r'''Makes colored text spanner with nibs.
.. container:: example
::
>>> staff = Staff("c'8 d'8 e'8 f'8")
>>> spanner = spannertools.make_colored_text_spanner_with_nibs()
>>> attach(spanner, staff[:])
>>> show(staff) # doctest: +SKIP
.. doctest::
>>> print(format(staff))
\new Staff {
\override TextSpanner #'bound-details #'left #'text = \markup {
\draw-line #'(0 . -1) }
\override TextSpanner #'bound-details #'left-broken #'text = ##f
\override TextSpanner #'bound-details #'right #'text = \markup {
\draw-line #'(0 . -1) }
\override TextSpanner #'bound-details #'right-broken #'text = ##f
\override TextSpanner #'color = #red
\override TextSpanner #'dash-fraction = #1
\override TextSpanner #'staff-padding = #2
\override TextSpanner #'thickness = #1.5
c'8 \startTextSpan
d'8
e'8
f'8 \stopTextSpan
\revert TextSpanner #'bound-details
\revert TextSpanner #'color
\revert TextSpanner #'dash-fraction
\revert TextSpanner #'staff-padding
\revert TextSpanner #'thickness
}
Renders 1.5-unit thick solid red spanner.
Draws nibs at beginning and end of spanner.
Does not draw nibs at line breaks.
Returns bracket spanner.
'''
from abjad.tools import spannertools
spanner = spannertools.TextSpanner()
pair = schemetools.SchemePair(0, -1)
markup_command = markuptools.MarkupCommand('draw-line', pair)
markup = markuptools.Markup(markup_command)
override(spanner).text_spanner.bound_details__left__text = markup
override(spanner).text_spanner.bound_details__left_broken__text = False
markup = markuptools.Markup(markup)
override(spanner).text_spanner.bound_details__right__text = markup
override(spanner).text_spanner.bound_details__right_broken__text = False
override(spanner).text_spanner.color = 'red'
override(spanner).text_spanner.dash_fraction = 1
override(spanner).text_spanner.staff_padding = 2
override(spanner).text_spanner.thickness = 1.5
return spanner
def make_solid_text_spanner_with_nib(
left_text,
direction=Up,
):
r'''Makes solid text spanner with nib at right.
.. container:: example
Solid text spanner forced above staff:
::
>>> staff = Staff("c'8 d'8 e'8 f'8")
>>> spanner = spannertools.make_solid_text_spanner_with_nib(
... 'foo',
... direction=Up,
... )
>>> attach(spanner, staff[:])
>>> show(staff) # doctest: +SKIP
.. doctest::
>>> print(format(staff))
\new Staff {
\override TextSpanner.bound-details.left.text = \markup { foo }
\override TextSpanner.bound-details.right-broken.text = ##f
\override TextSpanner.bound-details.right.text = \markup {
\draw-line
#'(0 . -1)
}
\override TextSpanner.dash-fraction = #1
\override TextSpanner.direction = #up
c'8 \startTextSpan
d'8
e'8
f'8 \stopTextSpan
\revert TextSpanner.bound-details
\revert TextSpanner.dash-fraction
\revert TextSpanner.direction
}
.. container:: example
Solid text spanner forced below staff:
>>> staff = Staff("c'8 d'8 e'8 f'8")
>>> spanner = spannertools.make_solid_text_spanner_with_nib(
... 'foo',
... direction=Down,
... )
>>> attach(spanner, staff[:])
>>> show(staff) # doctest: +SKIP
.. doctest::
>>> print(format(staff))
\new Staff {
\override TextSpanner.bound-details.left.text = \markup { foo }
\override TextSpanner.bound-details.right-broken.text = ##f
\override TextSpanner.bound-details.right.text = \markup {
\draw-line
#'(0 . 1)
}
\override TextSpanner.dash-fraction = #1
\override TextSpanner.direction = #down
c'8 \startTextSpan
d'8
e'8
f'8 \stopTextSpan
\revert TextSpanner.bound-details
\revert TextSpanner.dash-fraction
\revert TextSpanner.direction
}
Returns text spanner.
'''
from abjad.tools import spannertools
assert direction in (Up, Down)
text_spanner = spannertools.TextSpanner()
left_text = markuptools.Markup(left_text)
override(text_spanner).text_spanner.bound_details__left__text = left_text
if direction == Up:
pair = schemetools.SchemePair(0, -1)
else:
pair = schemetools.SchemePair(0, 1)
right_text = markuptools.Markup(
markuptools.MarkupCommand('draw-line', pair))
override(text_spanner).text_spanner.bound_details__right__text = right_text
override(text_spanner).text_spanner.bound_details__right_broken__text = \
False
override(text_spanner).text_spanner.dash_fraction = 1
override(text_spanner).text_spanner.direction = direction
return text_spanner
