-
Notifications
You must be signed in to change notification settings - Fork 20
/
Copy pathjianpu-ly.py
executable file
·1838 lines (1769 loc) · 96.1 KB
/
jianpu-ly.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!/usr/bin/env python
# (can be run with either Python 2 or Python 3)
r"""
# Jianpu (numbered musical notaion) for Lilypond
# v1.831 (c) 2012-2025 Silas S. Brown
# v1.826 (c) 2024 Unbored
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Homepage: http://ssb22.user.srcf.net/mwrhome/jianpu-ly.py
# Git repository: https://github.com/ssb22/jianpu-ly
# and on GitLab: https://gitlab.com/ssb22/jianpu-ly
# and on Bitbucket: https://bitbucket.org/ssb22/jianpu-ly
# and at https://gitlab.developers.cam.ac.uk/ssb22/jianpu-ly
# and in China: https://gitee.com/ssb22/jianpu-ly
# (The following docstring format is fixed, see --html)
Run jianpu-ly < text-file > ly-file (or jianpu-ly text-files > ly-file). There is experimental support for importing MusicXML via jianpu-ly piece.xml (or jianpu-ly piece.mxl > ly-file) but this does not work for all pieces.
# (Currently, MusicXML import must use .mxl extension and not redirect)
Normal text files are whitespace-separated and can contain words like the following. Usually the order of characters within a note does not matter, hence #1 is the same as 1# and '1 is the same as 1' and s1 is the same as 1s.
Scale going up: 1 2 3 4 5 6 7 1'
Accidentals: 1 #1 2 b2 1
Octaves: 1,, 1, 1 1' 1''
Shortcuts for 1' and 2': 8 9
Percussion beat: x
Change base octave: < >
Semiquaver, quaver, crotchet (16/8/4th notes): s1 q1 1
Alternate way to input semiquaver, quaver, crotchet: 1\\ 1\ 1 (any \ must go after the pitch not before)
Sticky durations (4 semiquavers then crotchet): KeepLength s1 1 1 1 c1
Dotted versions of the above (50% longer): s1. q1. 1.
Demisemiquaver, hemidemisemiquaver (32/64th notes): d1 h1
Minims (half notes) use dashes: 1 -
Dotted minim: 1 - -
Semibreve (whole note): 1 - - -
Time signature: 4/4
Time signature with quaver anacrusis (8th-note pickup): 4/4,8
Key signature (major): 1=Bb
Key signature (minor): 6=F#
Tempo: 4=85
Lyrics: L: here are the syl- la- bles (all on one line)
Lyrics (verse 1): L: 1. Here is verse one
Lyrics (verse 2): L: 2. Here is verse two
Hanzi lyrics (auto space): H: hanzi (with or without spaces)
Lilypond headers: title=the title (on a line of its own)
Guitar chords: chords=c2. g:7 c (on own line)
Fret diagrams: frets=guitar (on own line)
Multiple parts: NextPart
Instrument of current part: instrument=Flute (on a line of its own)
Multiple movements: NextScore
Prohibit page breaks until end of this movement: OnePage
Suppress bar numbers: NoBarNums
Suppress first-line indent: NoIndent
Ragged last line: RaggedLast
Old-style time signature: SeparateTimesig 1=C 4/4
Indonesian 'not angka' style: angka
Alternate Indonesian-style minim, dotted minim and semibreve: 1 . 1 . . 1 . . . (dot is treated as dash)
Add a Western staff doubling the tune: WithStaff
Tuplets: 3[ q1 q1 q1 ]
Grace notes before: g[#45] 1
Grace notes after: 1 ['1]g
Grace notes with durations: g[d4d5s6] 1
Simple chords: ,13'5 1 1b3 1 (chord numbers are sorted automatically)
Da capo: 1 1 Fine 1 1 1 1 1 1 DC
Repeat (with alternate endings): R{ 1 1 1 } A{ 2 | 3 }
Short repeats (percent): R4{ 1 2 }
Ties (like Lilypond's, if you don't want dashes): 1 ~ 1
Slurs (like Lilypond's): 1 ( 2 )
Erhu fingering (applies to previous note): Fr=0 Fr=4
Erhu symbol (applies to previous note): souyin harmonic up down bend tilde
Tremolo: 1/// - 1///5 -
Rehearsal letters: letterA letterB
Multibar rest: R*8
Dynamics (applies to previous note): \p \mp \f
Other 1-word Lilypond \ commands: \fermata \> \! \( \) etc
Text: ^"above note" _"below note"
Harmonic symbols above main notes: Harm: (music) :Harm (main music)
Other Lilypond code: LP: (block of code) :LP (each delimeter at start of its line)
Unicode approximation instead of Lilypond: Unicode
Split MIDI files per part: PartMidi
Ignored: % a comment
"""
import sys,os,re,shutil
from fractions import Fraction as F # requires Python 2.6+
if type(u"")==type(""): # Python 3
unichr,xrange = chr,range
from string import ascii_letters as letters
else: from string import letters # Python 2
def asUnicode(l):
if type(l)==type(u""): return l
return l.decode('utf-8')
try: from commands import getoutput
except: from subprocess import getoutput
def lilypond_minor_version():
global _lilypond_minor_version
try: return _lilypond_minor_version
except: pass
cmd = lilypond_command()
if cmd:
m=re.match(r".*ond-2\.([1-9][0-9])\.",cmd)
if m: _lilypond_minor_version = int(m.group(1))
else: _lilypond_minor_version = int(getoutput(cmd+" --version").split()[2].split('.')[1])
else: _lilypond_minor_version = 22 # assume 2.22 if we can't figure it out
return _lilypond_minor_version
def lilypond_command():
if hasattr(shutil,'which'):
w = shutil.which('lilypond')
if w: return 'lilypond'
elif not sys.platform.startswith("win"):
cmd = getoutput('which lilypond 2>/dev/null')
if os.path.exists(cmd): return 'lilypond'
placesToTry = ['/Applications/LilyPond.app/Contents/Resources/bin/lilypond'] # e.g. from Mac OS 10.4-10.14 Intel build https://web.archive.org/web/20221121202056/https://lilypond.org/download/binaries/darwin-x86/lilypond-2.22.2-1.darwin-x86.tar.bz2 (unpacked and moved to /Applications), or similarly 2.20 for macOS 10.15+ from https://gitlab.com/marnen/lilypond-mac-builder/-/package_files/9872804/download
placesToTry = ['/Applications/LilyPond-2.22.2.app/Contents/Resources/bin/lilypond','/Applications/LilyPond-2.20.0.app/Contents/Resources/bin/lilypond'] + placesToTry # if renamed from the above (try specific versions 1st, in case default is older)
placesToTry += ['lilypond-2.24.0/bin/lilypond','/opt/lilypond-2.24.0/bin/lilypond'] # if unpacked 2.24 (which drops the .app; in macOS 13, might need first to manually open at least lilypond and gs binaries for Gatekeeper approval if installing it this way)
for t in placesToTry:
if os.path.exists(t): return t
staff_size = float(os.environ.get("j2ly_staff_size",20))
# Normal: j2ly_staff_size=20
# Large: j2ly_staff_size=25.2
# Small: j2ly_staff_size=17.82
# Tiny: j2ly_staff_size=15.87
lyric_size = float(os.environ.get("j2ly_lyric_size",staff_size))
three_dots = u"\u22EE"
if not type(u"")==type(""): three_dots = three_dots.encode('utf-8') # Python 2
def find_grace_height(music):
# Need 3.5 if there's demisemiquavers with 2 octaves below.
# Can have 2.5 if there aren't any of those
# (Probably looks better if height is the same throughout the score,
# so we scan ahead to find what the most complex thing is.
# Could also change height every time, but would need to
# check if high-quality published music does that.
# Change every time would require differently parameterised versions of jianpu-grace-curve-stencil though.)
global grace_height
grace_height = 2.5
for word in music.split():
if word.startswith("g[") or word.endswith("]g"):
if "d" in word or ",," in word:
grace_height = 3.5 ; break
# TODO: more options, e.g. 3.0 if "d" but not ",," ? (will need to update grace_height dictionary in all_scores_start also)
def all_scores_start(inDat):
if lilypond_minor_version() < 20: errExit("Lilypond 2.18 and below is no longer supported") # 2.20 is in Ubuntu 20.04 LTS and 2.22 can be installed on a 2011 Mac; if you're stuck on an older EOL'd distro without Internet, use jianpu-ly 1.825 or earlier
r = r"""\version "2.%d.0"
#(set-global-staff-size %g)""" % ((
22 if "g[" in inDat or "]g" in inDat else 20),staff_size)
r += r"""
% un-comment the next line to remove Lilypond tagline:
% \header { tagline="" }
% comment out the next line if you're debugging jianpu-ly
% (but best leave it un-commented in production, since
% the point-and-click locations won't go to the user input)
\pointAndClickOff
\paper {
print-all-headers = ##t %% allow per-score headers
% un-comment the next line for A5:
% #(set-default-paper-size "a5" )
% un-comment the next line for no page numbers:
% print-page-number = ##f
% un-comment the next 3 lines for a binding edge:
% two-sided = ##t
% inner-margin = 20\mm
% outer-margin = 10\mm
% un-comment the next line for a more space-saving header layout:
% scoreTitleMarkup = \markup { \center-column { \fill-line { \magnify #1.5 { \bold { \fromproperty #'header:dedication } } \magnify #1.5 { \bold { \fromproperty #'header:title } } \fromproperty #'header:composer } \fill-line { \fromproperty #'header:instrument \fromproperty #'header:subtitle \smaller{\fromproperty #'header:subsubtitle } } } }
"""
if os.path.exists("/Library/Fonts/Arial Unicode.ttf"): r += r"""
% As jianpu-ly was run on a Mac, we include a Mac fonts workaround.
% The Mac version of Lilypond 2.18 used Arial Unicode MS as a
% fallback even in the Serif font, but 2.20 drops this in Serif
% (using it only in Sans), which means any Serif text (titles,
% lyrics etc) that includes Chinese will likely fall back to
% Japanese fonts which don't support all Simplified hanzi.
% This brings back 2.18's behaviour on 2.20+:
#(define fonts
(set-global-fonts
#:roman "Source Serif Pro,Source Han Serif SC,Times New Roman,Arial Unicode MS"
#:factor (/ staff-height pt 20)
))
"""
if has_lyrics: r += r"""
% Might need to enforce a minimum spacing between systems, especially if lyrics are below the last staff in a system and numbers are on the top of the next
system-system-spacing = #'((basic-distance . 7) (padding . 5) (stretchability . 1e7))
score-markup-spacing = #'((basic-distance . 9) (padding . 5) (stretchability . 1e7))
score-system-spacing = #'((basic-distance . 9) (padding . 5) (stretchability . 1e7))
markup-system-spacing = #'((basic-distance . 2) (padding . 2) (stretchability . 0))
"""
r += "}\n" # end of \paper block
r += r"""
%% 2-dot and 3-dot articulations
#(append! default-script-alist
(list
`(two-dots
. (
(stencil . ,ly:text-interface::print)
(text . ,#{ \markup \override #'(font-encoding . latin1) \center-align \bold ":" #})
(padding . 0.20)
(avoid-slur . inside)
(direction . ,UP)))))
#(append! default-script-alist
(list
`(three-dots
. (
(stencil . ,ly:text-interface::print)
(text . ,#{ \markup \override #'(font-encoding . latin1) \center-align \bold """+'"'+three_dots+'"'+r""" #})
(padding . 0.30)
(avoid-slur . inside)
(direction . ,UP)))))
"two-dots" =
#(make-articulation 'two-dots)
"three-dots" =
#(make-articulation 'three-dots)
\layout {
\context {
\Score
scriptDefinitions = #default-script-alist
}
}
note-mod =
#(define-music-function
(text note)
(markup? ly:music?)
#{
\tweak NoteHead.stencil #ly:text-interface::print
\tweak NoteHead.text
\markup \lower #0.5 \sans \bold #text
\tweak Rest.stencil #ly:text-interface::print
\tweak Rest.text
\markup \lower #0.5 \sans \bold #text
#note
#})"""
if re.search(r"(\s|^)(angka|Indonesian)(\s|$)",inDat): r += r"""
note-mod-angka = #(define-music-function (text note) (markup? ly:music?)
#{ \tweak NoteHead.stencil #ly:text-interface::print
\tweak NoteHead.text \markup \lower #0.5 \bold #text
\tweak Rest.stencil #ly:text-interface::print
\tweak Rest.text \markup \lower #0.5 \bold #text
#note #})
"""
if inner_beams_below: r += r"""
#(define (flip-beams grob)
(ly:grob-set-property!
grob 'stencil
(ly:stencil-translate
(let* ((stl (ly:grob-property grob 'stencil))
(centered-stl (ly:stencil-aligned-to stl Y DOWN)))
(ly:stencil-translate-axis
(ly:stencil-scale centered-stl 1 -1)
(* (- (car (ly:stencil-extent stl Y)) (car (ly:stencil-extent centered-stl Y))) 0) Y))
(cons 0 -0.8))))
"""
# Draw grace curve according to start and end mark.
# Modify from https://lists.gnu.org/archive/html/lilypond-user/2015-01/msg00142.html
r += r"""
%%=======================================================
#(define-event-class 'jianpu-grace-curve-event 'span-event)
#(define (add-grob-definition grob-name grob-entry)
(set! all-grob-descriptions
(cons ((@@ (lily) completize-grob-entry)
(cons grob-name grob-entry))
all-grob-descriptions)))
#(define (jianpu-grace-curve-stencil grob)
(let* ((elts (ly:grob-object grob 'elements))
(refp-X (ly:grob-common-refpoint-of-array grob elts X))
(X-ext (ly:relative-group-extent elts refp-X X))
(refp-Y (ly:grob-common-refpoint-of-array grob elts Y))
(Y-ext (ly:relative-group-extent elts refp-Y Y))
(direction (ly:grob-property grob 'direction RIGHT))
(x-start (* 0.5 (+ (car X-ext) (cdr X-ext))))
(y-start (+ (car Y-ext) %g))
(x-start2 (if (eq? direction RIGHT)(+ x-start 0.5)(- x-start 0.5)))
(x-end (if (eq? direction RIGHT)(+ (cdr X-ext) 0.2)(- (car X-ext) 0.2)))
(y-end (- y-start 0.5))
(stil (ly:make-stencil `(path 0.1
(moveto ,x-start ,y-start
curveto ,x-start ,y-end ,x-start ,y-end ,x-start2 ,y-end
lineto ,x-end ,y-end))
X-ext
Y-ext))
(offset (ly:grob-relative-coordinate grob refp-X X)))
(ly:stencil-translate-axis stil (- offset) X)))
#(add-grob-definition
'JianpuGraceCurve
`(
(stencil . ,jianpu-grace-curve-stencil)
(meta . ((class . Spanner)
(interfaces . ())))))
#(define jianpu-grace-curve-types
'(
(JianpuGraceCurveEvent
. ((description . "Used to signal where curve encompassing music start and stop.")
(types . (general-music jianpu-grace-curve-event span-event event))
))
))
#(set!
jianpu-grace-curve-types
(map (lambda (x)
(set-object-property! (car x)
'music-description
(cdr (assq 'description (cdr x))))
(let ((lst (cdr x)))
(set! lst (assoc-set! lst 'name (car x)))
(set! lst (assq-remove! lst 'description))
(hashq-set! music-name-to-property-table (car x) lst)
(cons (car x) lst)))
jianpu-grace-curve-types))
#(set! music-descriptions
(append jianpu-grace-curve-types music-descriptions))
#(set! music-descriptions
(sort music-descriptions alist<?))
#(define (add-bound-item spanner item)
(if (null? (ly:spanner-bound spanner LEFT))
(ly:spanner-set-bound! spanner LEFT item)
(ly:spanner-set-bound! spanner RIGHT item)))
jianpuGraceCurveEngraver =
#(lambda (context)
(let ((span '())
(finished '())
(current-event '())
(event-start '())
(event-stop '()))
`(
(listeners
(jianpu-grace-curve-event .
,(lambda (engraver event)
(if (= START (ly:event-property event 'span-direction))
(set! event-start event)
(set! event-stop event)))))
(acknowledgers
(note-column-interface .
,(lambda (engraver grob source-engraver)
(if (ly:spanner? span)
(begin
(ly:pointer-group-interface::add-grob span 'elements grob)
(add-bound-item span grob)))
(if (ly:spanner? finished)
(begin
(ly:pointer-group-interface::add-grob finished 'elements grob)
(add-bound-item finished grob)))))
(inline-accidental-interface .
,(lambda (engraver grob source-engraver)
(if (ly:spanner? span)
(begin
(ly:pointer-group-interface::add-grob span 'elements grob)))
(if (ly:spanner? finished)
(ly:pointer-group-interface::add-grob finished 'elements grob))))
(script-interface .
,(lambda (engraver grob source-engraver)
(if (ly:spanner? span)
(begin
(ly:pointer-group-interface::add-grob span 'elements grob)))
(if (ly:spanner? finished)
(ly:pointer-group-interface::add-grob finished 'elements grob)))))
(process-music .
,(lambda (trans)
(if (ly:stream-event? event-stop)
(if (null? span)
(ly:warning "No start to this curve.")
(begin
(set! finished span)
(ly:engraver-announce-end-grob trans finished event-start)
(set! span '())
(set! event-stop '()))))
(if (ly:stream-event? event-start)
(begin
(set! span (ly:engraver-make-grob trans 'JianpuGraceCurve event-start))
(set! event-start '())))))
(stop-translation-timestep .
,(lambda (trans)
(if (and (ly:spanner? span)
(null? (ly:spanner-bound span LEFT)))
(ly:spanner-set-bound! span LEFT
(ly:context-property context 'currentMusicalColumn)))
(if (ly:spanner? finished)
(begin
(if (null? (ly:spanner-bound finished RIGHT))
(ly:spanner-set-bound! finished RIGHT
(ly:context-property context 'currentMusicalColumn)))
(set! finished '())
(set! event-start '())
(set! event-stop '())))))
(finalize
(lambda (trans)
(if (ly:spanner? finished)
(begin
(if (null? (ly:spanner-bound finished RIGHT))
(set! (ly:spanner-bound finished RIGHT)
(ly:context-property context 'currentMusicalColumn)))
(set! finished '())))))
)))
jianpuGraceCurveStart =
#(make-span-event 'JianpuGraceCurveEvent START)
jianpuGraceCurveEnd =
#(make-span-event 'JianpuGraceCurveEvent STOP)
%%===========================================================
""" % {3.5: -0.2, 2.5: +0.32}[grace_height]
return r+"\n%{ The jianpu-ly input was:\n" + inDat.strip().replace("%}","%/}")+"\n%}\n\n"
def score_start():
ret = "\\score {\n"
if midi: ret += "\\unfoldRepeats\n"
ret += r"<< "
if not notehead_markup.noBarNums and not midi: ret += ("\\override Score.BarNumber #'break-visibility = #center-visible\n\\override Score.BarNumber #'Y-offset = -1\n\\set Score.barNumberVisibility = #(every-nth-bar-number-visible %d)" % bar_number_every)
return ret
bar_number_every = 5 # TODO customise? (anyway don't leave it numbering at start of system, doesn't work well in jianpu+lyrics)
def score_end(**headers):
ret = ">>\n"
if headers:
# since about Lilypond 2.7, music must come
# before the header block if it's per-score
ret += r"\header{"+'\n'
for k,v in headers.items(): ret+=k+'="'+v+'"\n'
ret += "}\n"
layoutExtra = ""
if not lyric_size == staff_size:
from math import log
lSize = log(lyric_size/staff_size)*6/log(2)
if lSize > 3: sys.stderr.write("WARNING: potential layout problems; consider increasing j2ly_staff_size to be closer to j2ly_lyric_size\n") # TODO: is 3 a good threshold for this warning? (need to check different Lilypond versions)
layoutExtra=r" \override Lyrics.LyricText.font-size = #"+("+" if lSize>=0 else "")+str(lSize)+" "
if notehead_markup.noIndent: layoutExtra += ' indent = 0.0 '
if notehead_markup.raggedLast: layoutExtra += ' ragged-last = ##t '
if notehead_markup.noBarNums: layoutExtra += r' \context { \Score \remove "Bar_number_engraver" } '
if midi: ret += r"\midi { \context { \Score tempoWholesPerMinute = #(ly:make-moment 84 4)}}" # will be overridden by any \tempo command used later
else: ret += r"\layout{"+layoutExtra+r"""
\context {
\Global
\grobdescriptions #all-grob-descriptions
}
""" + "}"
return ret + " }"
def uniqName():
global uniqCount
r = str(uniqCount) ; uniqCount += 1
return r.translate((letters*5)[:256])
def jianpu_voice_start(isTemp=0):
if not isTemp and maxBeams >= 2: stemLenFrac = "0.5" # sometimes needed if the semiquavers occur in isolation rather than in groups (TODO do we need to increase this for 3+ beams in some cases?)
else: stemLenFrac = "0"
voiceName = uniqName()
r = (r"""\new Voice="%s" {"""%voiceName)
r += r"""
\override Beam #'transparent = ##f"""
if not_angka:
r +=r"""
\override Stem #'direction = #UP
\override Tie #'staff-position = #-2.5
\tupletDown"""
stemLenFrac=str(0.4+0.2*max(0,maxBeams-1))
else: r += r"""
\override Stem #'direction = #DOWN
\override Tie #'staff-position = #2.5
\tupletUp
\tieUp"""
r += (r"""
\override Stem #'length-fraction = #%s
\override Beam #'beam-thickness = #0.1
\override Beam #'length-fraction = #0.5
%s
\override Voice.Rest #'style = #'neomensural %% this size tends to line up better (we'll override the appearance anyway)
\override Accidental #'font-size = #-4
\override TupletBracket #'bracket-visibility = ##t""" %
(stemLenFrac,
r"\override Beam.after-line-breaking = #flip-beams" if inner_beams_below else ""
))
r += "\n"+r"""\set Voice.chordChanges = ##t %% 2.19 bug workaround""" # LilyPond 2.19.82: \applyOutput docs say "called for every layout object found in the context Context at the current time step" but 2.19.x breaks this by calling it for ALL contexts in the current time step, hence breaking our WithStaff by applying our jianpu numbers to the 5-line staff too. Obvious workaround is to make our function check that the context it's called with matches our jianpu voice, but I'm not sure how to do this other than by setting a property that's not otherwise used, which we can test for in the function. So I'm 'commandeering' the "chordChanges" property (there since at least 2.15 and used by Lilypond only when it's in chord mode, which we don't use, and if someone adds a chord-mode staff then it won't print noteheads anyway): we will substitute jianpu numbers for noteheads only if chordChanges = #t.
return r+"\n", voiceName
def jianpu_staff_start(inst=None,withStaff=False):
# (we add "BEGIN JIANPU STAFF" and "END JIANPU STAFF" comments to make it easier to copy/paste into other Lilypond files)
if withStaff: inst = None # we'll put the label on the 5-line staff (TODO: use StaffGroup or something?)
if not_angka: r=r"""
%% === BEGIN NOT ANGKA STAFF ===
\new RhythmicStaff \with {"""
else: r=r"""
%% === BEGIN JIANPU STAFF ===
\new RhythmicStaff \with {
\consists "Accidental_engraver" """
r += r"""
\consists \jianpuGraceCurveEngraver"""
if inst: r += 'instrumentName = "'+inst+'"'
if withStaff: r+=r"""
%% Limit space between Jianpu and corresponding-Western staff
\override VerticalAxisGroup.staff-staff-spacing = #'((minimum-distance . 7) (basic-distance . 7) (stretchability . 0))
""" # (whether this is needed or not depends on Lilypond version; 2.22 puts more space than 2.18,2.20. Must set higher than 5, which sometimes gets collisions between beams in 2.20)
r+=r"""
%% Get rid of the stave but not the barlines:
\override StaffSymbol #'line-count = #0 %% tested in 2.15.40, 2.16.2, 2.18.0, 2.18.2, 2.20.0 and 2.22.2
\override BarLine #'bar-extent = #'(-2 . 2) %% LilyPond 2.18: please make barlines as high as the time signature even though we're on a RhythmicStaff (2.16 and 2.15 don't need this although its presence doesn't hurt; Issue 3685 seems to indicate they'll fix it post-2.18)
$(add-grace-property 'Voice 'Stem 'direction DOWN)
$(add-grace-property 'Voice 'Slur 'direction UP)
$(add-grace-property 'Voice 'Stem 'length-fraction 0.5)
$(add-grace-property 'Voice 'Beam 'beam-thickness 0.1)
$(add-grace-property 'Voice 'Beam 'length-fraction 0.3)
$(add-grace-property 'Voice 'Beam 'after-line-breaking flip-beams)
$(add-grace-property 'Voice 'Beam 'Y-offset %.1f)
$(add-grace-property 'Voice 'NoteHead 'Y-offset %.1f)
}
{ """ % (grace_height, grace_height)
j,voiceName = jianpu_voice_start()
r += j+r"""
\override Staff.TimeSignature #'style = #'numbered
\override Staff.Stem #'transparent = ##t
"""
return r, voiceName
def jianpu_staff_end():
# \bar "|." is added separately if there's not a DC etc
if not_angka: return "} }\n% === END NOT ANGKA STAFF ===\n"
else: return "} }\n% === END JIANPU STAFF ===\n"
def midi_staff_start():
return r"""
%% === BEGIN MIDI STAFF ===
\new Staff { \new Voice="%s" {""" % (uniqName(),)
def midi_staff_end(): return "} }\n% === END MIDI STAFF ===\n"
def western_staff_start(inst=None):
r = r"""
%% === BEGIN 5-LINE STAFF ===
\new Staff """
if inst: r += r'\with { instrumentName = "'+inst+'" } '
voiceName = uniqName()
return (r+r"""{
\override Score.SystemStartBar.collapse-height = #11 %% (needed on 2.22)
\new Voice="%s" {
#(set-accidental-style 'modern-cautionary)
\override Staff.TimeSignature #'style = #'numbered
\set Voice.chordChanges = ##f %% for 2.19.82 bug workaround
""" % (voiceName,)), voiceName
def western_staff_end(): return "} }\n% === END 5-LINE STAFF ===\n"
def lyrics_start(voiceName):
return r'\new Lyrics = "I%s" { \lyricsto "%s" { ' % (uniqName(),voiceName)
def lyrics_end(): return "} }"
inner_beams_below = True # Use stencil reflection to invert Lilypond's normal beam positioning (like in David Zhang's jianpu10a.ly) - more accurately reflects jianpu typography but can result in octave dots being too far down because beam spacing is done per system not per beam
dashes_as_ties = True # Implement dash (-) continuations as invisible ties rather than rests; sometimes works better in awkward beaming situations
use_rest_hack = True # Implement some short rests as notes (and if there are lyrics, creates temporary voices so the lyrics miss them); sometimes works better for beaming (at least in 2.15 through 2.24)
if __name__=="__main__" and '--noRestHack' in sys.argv: # TODO: document
use_rest_hack=False ; sys.argv.remove('--noRestHack')
assert not (use_rest_hack and not dashes_as_ties), "This combination has not been tested"
def errExit(msg):
if __name__=="__main__":
sys.stderr.write("Error: "+msg+"\n")
sys.exit(1)
else: raise Exception(msg)
def scoreError(msg,word,line):
if len(word)>60: word=word[:50]+"..."
msg += " %s in score %d" % (word,scoreNo)
if len(line)>600: line=line[:500]+"..."
if not word in line: pass # above truncations caused problems
elif "xterm" in os.environ.get("TERM",""): # use xterm underline escapes
msg += "\n"+re.sub(r"(\s|^)"+re.escape(word)+r"(?=\s|$)",lambda m:m.group(1)+"\x1b[4m"+word+"\x1b[m",line)
elif re.match('[ -~]*$',line): # all ASCII: we can underline the word with ^^s
msg += "\n"+line+"\n"+re.sub('[^^]',' ',re.sub(r"(\s|^)"+re.escape(word)+r"(?=\s|$)",lambda m:m.group(1)+'^'*(len(word)),line))
else: # don't try to underline the word (at least not without ANSI): don't know how the terminal will handle character widths
msg += "\nin this line: "+line
errExit(msg)
placeholders = {
# for accidentals and word-fitting to work
# (we make them relative to the actual key later
# so that MIDI pitches are correct)
'0':'r',
'1':'c',
'2':'d',
'3':'e',
'4':'f',
'5':'g',
'6':'a',
'7':'b',
'x':'c',
'-':'r'}
def addOctaves(octave1,octave2):
octave2=octave2.replace(">","'").replace("<",",") # so it can be used with a base-octave change
while octave1:
if octave1[0] in "'>": # go up
if ',' in octave2: octave2 = octave2[:-1]
else: octave2 += "'"
else: # , or < : go down
if "'" in octave2: octave2 = octave2[:-1]
else: octave2 += ","
octave1=octave1[1:]
return octave2
class NoteheadMarkup:
def __init__(self,graceType=None):
self.initOneScore()
self.graceType = graceType
def initOneScore(self):
self.barLength = 64 ; self.beatLength = 16 # in 64th notes
self.barPos = self.startBarPos = F(0)
self.inBeamGroup = self.lastNBeams = self.onePage = self.noBarNums = self.noIndent = self.raggedLast = self.separateTimesig = self.withStaff = 0
self.keepLength = 0
self.last_octave = self.base_octave = ""
self.octavesSeen = []
self.current_accidentals = {} # used to predict whether Lilypond will draw the accidental or not, for beam spacing purposes
self.barNo = 1
self.tuplet = (1,1)
self.last_figures = None
self.last_was_rest = False
self.notesHad = []
self.unicode_approx = []
self.rplacNextIfStillInBeam = None
self.graceType = None
self.current_chord = None
def endScore(self):
if self.barPos == self.startBarPos: pass
elif os.environ.get("j2ly_sloppy_bars",""): sys.stderr.write("Wrong bar length at end of score %d ignored (j2ly_sloppy_bars set)\n" % scoreNo)
elif self.startBarPos and not self.barPos: errExit("Score %d should end with a %g-beat bar to make up for the %g-beat anacrusis bar. Set j2ly_sloppy_bars environment variable if you really want to break this rule." % (scoreNo,self.startBarPos/self.beatLength,(self.barLength-self.startBarPos)/self.beatLength)) # this is on the music theory syllabi at about Grade 3, but you can get up to Grade 5 practical without actually covering it, so we'd better not expect all users to understand "final bar does not make up for anacrusis bar"
else: errExit("Incomplete bar at end of score %d (%g beats)" % (scoreNo,self.barPos*1.0/self.beatLength))
def setTime(self,num,denom):
self.barLength = int(64*num/denom)
if denom>4 and num%3==0: self.beatLength = 24 # compound time
else: self.beatLength = 16
def setAnac(self,denom,dotted):
self.barPos = F(self.barLength)-F(64)/denom
if dotted: self.barPos -= F(64)/denom/2
if self.barPos<0: errExit("Anacrusis is longer than bar in score %d" % scoreNo) # but anacrusis being exactly equal to bar is OK: we'll just interpret that as no anacrusis
self.startBarPos = self.barPos
def wholeBarRestLen(self): return {96:"1.",48:"2.",32:"2",24:"4.",16:"4",12:"8.",8:"8"}.get(self.barLength,"1") # TODO: what if irregular?
def baseOctaveChange(self,change):
self.base_octave = addOctaves(change,self.base_octave)
def __call__(self,figures,nBeams,dots,octave,accidental,tremolo,word,line):
# figures is a chord string of '1'-'7', or 'x' or '0' or '-'
# nBeams is 0, 1, 2 .. etc (number of beams for this note)
# dots is "" or "." or ".." etc (extra length)
# octave is "", "'", "''", "'''", ",", ",," or ",,,"
# accidental is "", "#", "b"
# tremolo is "" or ":32"
# word,line is for error handling
if len(figures)>1:
if accidental and not_angka: scoreError("Accidentals in chords not yet implemented in Indonesian not-angka mode:",word,line)
if '0' in figures: scoreError("Can't have rest in chord:",word,line)
if 'x' in figures: scoreError("Can't have percussion beat in chord:",word,line)
self.notesHad.append(figures)
isChord = len(figures)>1
if isChord:
chord_ret,octave,placeholder_chord = chordNotes_markup(re.sub('[qsdh.]','',word)) # word w/out durations
if not midi and not western: placeholder_chord = "c"
else: # not isChord
placeholder_chord = placeholders[figures]
invisTieLast = dashes_as_ties and self.last_figures and figures=="-" and not self.last_was_rest
self.last_was_rest = (figures=='0' or (figures=='-' and self.last_was_rest))
aftrLastNonDash = tieEnd = ""
add_cautionary_accidental = False
if invisTieLast: # (so figures == "-")
if self.barPos==0 and not midi and not western and not self.last_figures=="x":
# dash over barline: write as new note
figures = self.last_figures
aftrLastNonDash = r'\=JianpuTie('
tieEnd = r'\=JianpuTie)'
add_cautionary_accidental = self.last_accidental
tremolo = self.last_tremolo
else:
if self.barPos==0 and not midi and not western and not self.last_figures=="x": sys.stderr.write("Warning: jianpu barline-crossing tie won't be done right because your Lilypond version is older than 2.20\n")
if self.barPos==0: tremolo = self.last_tremolo
if self.current_chord: # a chord is currently in progress, and we're extending it with a tie
isChord = True
chord_ret,octave,placeholder_chord = chordNotes_markup(re.sub('[qsdh.]','',self.current_chord))
if not midi and not western: placeholder_chord = "c"
else: # not a chord, so we can assume len(self.last_figures)==1
placeholder_chord = placeholders[self.last_figures]
octave = self.last_octave # for MIDI or 5-line
accidental = self.last_accidental # ditto
else: # not invisTieLast
if not isChord: octave=addOctaves(octave,self.base_octave)
if not octave in [",,,",",,",",","","'","''","'''"]: scoreError("Can't handle octave "+octave+" in",word,line)
self.last_octave = octave
self.octavesSeen.append({",,,":-3,",,":-2,",":-1,"":0,"'":1,"''":2,"'''":3}[octave]) # for figuring out the best clef with WithStaff
self.last_tremolo = tremolo
if isChord: self.current_chord = word
else: self.current_chord = None
if not figures=="-": self.last_figures = figures
if not isChord and not accidental in ["","#","b"]: scoreError("Can't handle accidental "+accidental+" in",word,line)
self.last_accidental = accidental
ret = ""
if self.barPos==0 and self.barNo > 1:
ret += "| " # barline in Lilypond file: not strictly necessary but may help readability
if self.onePage and not midi: ret += r"\noPageBreak "
ret += "%{ bar "+str(self.barNo)+": %} "
self.notesHad.insert(-1,"|")
if not octave in self.current_accidentals: self.current_accidentals[octave] = [""]*7
if nBeams==None: # unspecified
if self.keepLength:
nBeams = self.lastNBeams
else: nBeams = 0
if figures=="-" or all('1'<=figure<='7' and not accidental==self.current_accidentals[octave][int(figure)-1] for figure in list(figures)) and nBeams > self.lastNBeams: leftBeams = nBeams # beam needs to fit under the new accidental (or the dash which might be slightly to the left of where digits are), but if it's no more than last note's beams then we'll hang it only if in same beat. (TODO: the current_accidentals logic may need revising if other accidental styles are used, e.g. modern-cautionary, although then would need to check anyway if our \consists "Accidental_engraver" is sufficient)
# TODO: if figures=="0" then that might be typeset a bit to the left as well (because it's also a rest), however extending the line TOO far left in this case could be counterproductive
elif self.inBeamGroup:
if nBeams < self.lastNBeams: leftBeams = nBeams
else: leftBeams = self.lastNBeams
else: leftBeams = 0
if leftBeams: assert nBeams, "following logic assumes if (leftBeams or nBeams) == if nBeams"
aftrlast0 = ""
if not nBeams and self.inBeamGroup:
if not self.inBeamGroup=="restHack":
aftrlast0 = "] "
self.inBeamGroup = 0
length = 4 ; b = 0 ; toAdd = F(16) # crotchet
while b < nBeams: b,length,toAdd = b+1,length*2,toAdd/2
toAdd0 = toAdd
for _ in dots:
toAdd0 /= 2 ; toAdd += toAdd0
toAdd_preTuplet = toAdd
if not self.tuplet[0]==self.tuplet[1]:
toAdd = toAdd*self.tuplet[0]/self.tuplet[1]
if nBeams and not midi and not western: # must set these unconditionally regardless of what we think their current values are (Lilypond's own beamer can change them from note to note)
if not_angka:
leftBeams=nBeams
if (self.barPos+toAdd)%self.beatLength == 0: nBeams = 0
ret += (r"\set stemLeftBeamCount = #%d"+"\n") % leftBeams
ret += (r"\set stemRightBeamCount = #%d"+"\n") % nBeams
if not_angka: nBeams = leftBeams
need_space_for_accidental = False
for figure in list(figures):
if '1'<=figure<='7':
if not accidental==self.current_accidentals[octave][int(figure)-1]:
need_space_for_accidental = True
self.current_accidentals[octave][int(figure)-1] = accidental # TODO: not sensible (assumes accidental applies to EVERY note in the chord, see above)
inRestHack = replaceLast = 0
if not midi and not western:
if ret: ret = ret.rstrip()+"\n" # try to keep the .ly code vaguely readable
if octave=="''" and not invisTieLast: ret += r" \once \override Score.TextScript.outside-staff-priority = 45" # inside bar numbers etc
if isChord and not figures=="-":
ret += chord_ret
elif figures=="-":
if not_angka: figureDash=u"."
else: figureDash=u"\u2013"
if not type(u"")==type(""):
figureDash=figureDash.encode('utf-8')
ret += (r' \note-mod-angka "' if not_angka else r' \note-mod "')+figureDash+'" '
else: # single, non-dash note
s = str(figures)
if not_angka and accidental:
u338,u20e5=u"\u0338",u"\u20e5" # TODO: the \ looks better than the / in default font
if not type("")==type(u""): u338,u20e5=u338.encode('utf-8'),u20e5.encode('utf-8')
s += {'#':u338,'b':u20e5}[accidental]
ret += (r' \note-mod-angka "' if not_angka else r' \note-mod "')+s+'" '
if self.rplacNextIfStillInBeam and leftBeams and nBeams: replaceLast = self.rplacNextIfStillInBeam # didn't need the rest-hack here after all
self.rplacNextIfStillInBeam = None
if placeholder_chord == "r" and use_rest_hack and nBeams and not (leftBeams and not not_angka):
placeholder_chord = "c"
# C to work around diagonal-tail problem with
# some isolated quaver rests in some Lilypond
# versions (usually at end of bar); new voice
# so lyrics miss it as if it were a rest:
if has_lyrics and not self.withStaff: # (OK if self.withStaff: lyrics will be attached to that instead)
self.rplacNextIfStillInBeam = ret
ret = jianpu_voice_start(1)[0]+ret
inRestHack = 1
if self.inBeamGroup and not self.inBeamGroup=="restHack": aftrlast0 = "] "
if placeholder_chord.startswith("<"): ret += placeholder_chord # chord in western or midi
elif not isChord or figures.startswith("-"): # single note or rest
ret += placeholder_chord
if midi or western or not not_angka: ret += {"":"", "#":"is", "b":"es"}[accidental]
if not placeholder_chord=="r": ret += {"":"'","'":"''","''":"'''","'''":"''''",",":"",",,":",",",,,":",,"}[octave] # for MIDI + Western, put it so no-mark starts near middle C
if add_cautionary_accidental: ret += "!"
ret += ("%d" % length) + dots
if self.rplacNextIfStillInBeam: self.rplacNextIfStillInBeam += ("r%d" % length) + dots + '['
if tremolo:
if midi or western:
if placeholder_chord.startswith("<") and len(placeholder_chord.split())==4:
previous,n1,n2,gtLenDot = ret.rsplit(None,3)
previous=previous[:-1] # drop <
ret = r"%s\repeat tremolo %d { %s32 %s32 }" % (previous,int(toAdd_preTuplet/4),n1,n2)
else: ret += tremolo
elif lilypond_minor_version()>=22:
if dots: ret += r"""_\tweak outside-staff-priority ##f ^\tweak avoid-slur #'inside _\markup {\with-dimensions #'(0 . 0) #'(2.8 . 2.1) \postscript "1.6 -0.2 moveto 2.6 0.8 lineto 1.8 -0.4 moveto 2.8 0.6 lineto 2.0 -0.6 moveto 3.0 0.4 lineto stroke" } %{ requires Lilypond 2.22+ %} """
else: ret += r"""_\tweak outside-staff-priority ##f ^\tweak avoid-slur #'inside _\markup {\with-dimensions #'(0 . 0) #'(2.5 . 2.1) \postscript "1.1 0.4 moveto 2.1 1.4 lineto 1.3 0.2 moveto 2.3 1.2 lineto 1.5 0.0 moveto 2.5 1.0 lineto stroke" } %{ requires Lilypond 2.22+ %} """
elif dots: ret += r"""_\tweak outside-staff-priority ##f ^\tweak avoid-slur #'inside _\markup {\with-dimensions #'(0 . 0) #'(2.8 . 2.6) \postscript "1.4 1.6 moveto 2.4 2.6 lineto 1.6 1.4 moveto 2.6 2.4 lineto 1.8 1.2 moveto 2.8 2.2 lineto stroke" } %{ requires Lilypond 2.20 %} """
else: ret += r"""_\tweak outside-staff-priority ##f ^\tweak avoid-slur #'inside _\markup {\with-dimensions #'(0 . 0) #'(2.5 . 2.6) \postscript "1.1 1.6 moveto 2.1 2.6 lineto 1.3 1.4 moveto 2.3 2.4 lineto 1.5 1.2 moveto 2.5 2.2 lineto stroke" } %{ requires Lilypond 2.20 %} """
# Octave dots:
if not midi and not western and not '-' in figures:
if not nBeams:
oDict = {",":r"-\tweak #'Y-offset #-1.2 ",
",,":r"-\tweak #'Y-offset #-2 ",
",,,":r"-\tweak #'Y-offset #-2.7 ",
}
ret += oDict.get(octave,"")
elif self.graceType:
oDict = {",":r"-\tweak #'Y-offset #%.1f " % (grace_height-1-nBeams*0.3),
",,":r"-\tweak #'Y-offset #%.1f " % (grace_height-1.6-nBeams*0.3),
",,,":r"-\tweak #'Y-offset #%.1f " % (grace_height-2-nBeams*0.3),
}
ret += oDict.get(octave,"")
# Ugly fix for grace dot positions
x_offset=0.6
if self.graceType: x_offset=0.4
oDict = {"":"",
"'":"^.",
"''":r"-\tweak #'X-offset #%.1f ^\two-dots " % x_offset,
"'''":r"-\tweak #'X-offset #%.1f ^\three-dots " % x_offset,
",":r"-\tweak #'X-offset #%.1f _. " % x_offset,
",,":r"-\tweak #'X-offset #%.1f _\two-dots " % x_offset,
",,,":r"-\tweak #'X-offset #%.1f _\three-dots " % x_offset}
if not_angka: oDict.update({
"'":r"-\tweak #'extra-offset #'(0.4 . 2.7) -\markup{\bold .}",
"''":r"-\tweak #'extra-offset #'(0.4 . 3.5) -\markup{\bold :}",
"'''":r"-\tweak #'extra-offset #'(0.4 . 4.3) -\markup{\bold "+three_dots+"}",
})
ret += oDict[octave]
if nBeams and (not self.inBeamGroup or (self.inBeamGroup=="restHack" and not replaceLast) or inRestHack) and not midi and not western:
# We need the above stemLeftBeamCount, stemRightBeamCount override logic to work even if we're an isolated quaver, so do this:
ret += '['
self.inBeamGroup = 1
self.barPos += toAdd
if self.graceType and self.barPos == self.barLength:
is_isolated_note = ret.endswith("[")
if is_isolated_note:
# Lilypond doesn't like isolated beamed notes in \grace
# so introduce a skip note for it to beam to.
# Putting the skip note BEFORE the grace note or AFTER the afterGrace note
# might help if aligning jianpu with 5-line staves.
if self.graceType == "before":
ret = r"s%d [ \jianpuGraceCurveEnd %s" % (length,ret.replace("[",""))
else:
ret += r" \jianpuGraceCurveEnd s%d" % length
else:
ret = r" \jianpuGraceCurveEnd " + ret
# sys.stderr.write(accidental+figure+octave+dots+"/"+str(nBeams)+"->"+str(self.barPos)+" ") # if need to see where we are
if self.barPos > self.barLength: errExit("(notesHad=%s) barcheck fail: note crosses barline at \"%s\" with %d beams (%d skipped from %d to %d, bypassing %d), scoreNo=%d barNo=%d (but the error could be earlier)" % (' '.join(self.notesHad),figures,nBeams,toAdd,self.barPos-toAdd,self.barPos,self.barLength,scoreNo,self.barNo))
if self.barPos%self.beatLength == 0 and self.inBeamGroup: # (self.inBeamGroup is set only if not midi/western)
# jianpu printouts tend to restart beams every beat
# (but if there are no beams running anyway, it occasionally helps typesetting to keep the logical group running, e.g. to work around bugs involving beaming a dash-and-rest beat in 6/8) (TODO: what if there's a dash-and-rest BAR? [..]-notated beams don't usually work across barlines
ret += ']'
self.inBeamGroup = 0 # DON'T reset lastNBeams here (needed for start-of-group accidental logic)
elif inRestHack and self.inBeamGroup:
ret += ']'
self.inBeamGroup = "restHack"
self.lastNBeams = nBeams
beamC = u'\u0333' if nBeams>=2 else u'\u0332' if nBeams==1 else u""
self.unicode_approx.append({'#':u"\u266f",'b':u"\u266d"}.get(0 if invisTieLast else accidental,u"")+(u"-" if invisTieLast else figures[-1:])+beamC+(u"" if invisTieLast else (u'\u0323' if "," in octave else u'\u0307' if "'" in octave else u""))+u''.join(c+beamC for c in dots)+(u"" if self.inBeamGroup else u" ")) # (NB inBeamGroup is correct only if not midi and not western)
if self.barPos == self.barLength:
self.unicode_approx[-1]=self.unicode_approx[-1].rstrip()+u'\u2502'
self.barPos = 0 ; self.barNo += 1
self.current_accidentals = {}
if invisTieLast:
if midi or western:
b4last, aftrlast = "", " ~"
if tremolo and placeholder_chord.startswith("<"):
aftrlast = "" # can't tie this kind of tremolo as of Lilypond 2.24 (get warning: Unattached TieEvent)
# elif not figures=='-':
# b4last,aftrlast = r"\once \override Tie #'transparent = ##t \once \override Tie #'staff-position = #0 "," ~"
else:
b4last, aftrlast = "", ""
else: b4last,aftrlast = "",""
if figures=="x" and western: ret = r"\once \override NoteHead.style = #'cross \once \override NoteHead.no-ledgers = ##t " + ret
if inRestHack: ret += " } " # end temporary voice for the "-" (non)-note
elif tieEnd: ret += ' '+tieEnd # end of JianpuTie curve
return aftrLastNonDash,figures=='-',b4last,replaceLast,aftrlast0+aftrlast,ret, need_space_for_accidental, nBeams,octave
def parseNote(word,origWord,line):
if word==".": word = "-"
word = word.replace("8","1'").replace("9","2'")
if type(u"")==type(""): word = word.replace(u"\u2019","'")
else: word=word.replace(u"\u2019".encode('utf-8'),"'")
if "///" in word: tremolo,word=":32",word.replace("///","",1)
else: tremolo = ""
if not re.match(r"[0-7x.,'cqsdh\\#b-]+$",word): # unrecognised stuff in it: flag as error, rather than ignoring and possibly getting a puzzling barsync fail
scoreError("Unrecognised command",origWord,line)
figures = ''.join(re.findall('[01234567x-]',word))
dots = "".join(c for c in word if c==".")
nBeams = ''.join(re.findall(r'[cqsdh\\]',word))
if re.match(r"[\\]+$",nBeams): nBeams=len(nBeams) # requested by a user who found British note-length names hard to remember; won't work if the \ is placed at the start, as that'll be a Lilypond command
elif nBeams:
try: nBeams = list("cqsdh").index(nBeams)
except ValueError: scoreError("Can't calculate number of beams from "+nBeams+" in",origWord,line)
else: nBeams=None # unspecified
octaves = re.findall("'+|,+",word)
# chords of course accept multiple octaves
if len(octaves)>1 and len(figures) == 1: scoreError("Multiple octaves should not applied to a single note:",origWord,line)
if octaves: octave = octaves[0]
else: octave = ""
accidental = "".join(c for c in word if c in "#b")
if len(figures) > 1: # octave + accidental dealt with separately BUT still need to keep one for the beaming and need_space_for_accidental logic (TODO actually current_accidentals needs rewriting for chords, but this works in most cases for now)
accidental = accidental[:1]
return figures,nBeams,dots,octave,accidental,tremolo
def write_docs():
# Write an HTML or Markdown version of the doc string
def htmlify(l):
if "--html" in sys.argv:
return re.sub('([hdDsS]emi)',r'\1­',l.replace("&","&").replace("<","<").replace(">",">")).replace("approximation","approx­imation").replace("instrument=Flute","instrument=<wbr>Flute")
else: return l
inTable = 0 ; justStarted=1
for line in __doc__.split("\n"):
if line.startswith("#") or not line.strip(): continue
if ":" in line and line.split(":",1)[1].strip():
toGet,shouldType = line.split(":",1)
if not inTable:
if "--html" in sys.argv:
print ("<table border>") # "<tr><th>To get:</th><th>Type:</th></tr>"
else: print ("")
inTable = 1
if re.match(r".*[A-Za-z]\)$",shouldType):
shouldType,note = shouldType.rsplit("(",1)
note = " ("+note
else: note = ""
if "--html" in sys.argv: print ("<tr><td>"+htmlify(toGet.strip())+"</td><td><kbd>"+htmlify(shouldType.strip())+"</kbd>"+htmlify(note)+"</td>")
else: print (toGet.strip()+": `"+shouldType.strip()+"`"+note+"\n")
else:
if "--markdown" in sys.argv: print ("")
elif inTable: print ("</table>")
elif not justStarted: print ("<br>")
inTable=justStarted=0
print (htmlify(line))
if inTable and "--html" in sys.argv: print ("</table>")
def getInput0():
inDat = []
for f in sys.argv[1:]:
if f.endswith(".mxl"):
import zipfile ; z=zipfile.ZipFile(f)
for F in z.infolist():
if not F.filename=="META-INF/container.xml":
b = z.read(F)
if type("")==type(u""): b=b.decode('utf-8')
inDat.append(b)
else:
try:
try: inDat.append(open(f,encoding="utf-8").read()) # Python 3: try UTF-8 first
except: inDat.append(open(f).read()) # Python 2, or Python 3 with locale-default encoding in case it's not UTF-8
except: errExit("Unable to read file "+f)
if inDat: return inDat
if not sys.stdin.isatty():
return [fix_utf8(sys.stdin,'r').read()]
# They didn't give us any input. Try to use a
# file chooser. If that fails, just print the
# help text.
if os.path.exists('/usr/bin/osascript'):
f = os.popen("osascript -e $'tell application \"System Events\"\\nactivate\\nset f to choose file\\nend tell\\nPOSIX path of f'").read().rstrip()
if f:
try: return [open(f,encoding="utf-8").read()]
except: return [open(f).read()]
write_help() ; raise SystemExit
def write_help():
write_version()
sys.stderr.write("\n".join(l for l in __doc__.split("\n") if l.strip() and not l.startswith("#"))+"\n")
def write_version():
versions = [] # output the biggest (might not be 1st listed)
for l in __doc__.split("\n"):
if l.startswith("# v"): versions.append((float(l[len("# v"):l.index(' ',len("# v"))]),l.replace("#","jianpu-ly",1)+"\n\n"))
sys.stderr.write(max(versions)[1])
def get_input():
inDat = getInput0()
for i in xrange(len(inDat)):
if inDat[i].startswith('\xef\xbb\xbf'):
inDat[i] = inDat[i][3:]
if inDat[i].startswith(r'\version'): errExit("jianpu-ly does not READ Lilypond code.\nPlease see the instructions.")
elif inDat[i].startswith("<?xml"):
inDat[i] = xml2jianpu(inDat[i])
return " NextScore ".join(inDat)