Autor Thema: Eigene Papierformate definieren  (Gelesen 4202 mal)

juppes

  • Member
Eigene Papierformate definieren
« am: Dienstag, 19. Juli 2011, 14:50 »
heute habe ich etwas ganz Spezielles: ich stoße mich von jeher daran, daß man in der Praxis gezwungen ist, DIN A4 verwenden zu müssen. Dieses Papierformat ist für Musik in aller Regel zu klein, wenn ein Stück mehr als eineinhalb Minuten dauert und wenig Pausen hat, in denen man blättern kann. Man muß sich entweder helfen, indem man sich drei Seiten auf den Notenständer stellt oder indem man mit allerlei Tricks die Noten doch noch auf zwei Seiten quetscht. In alten Zeiten waren Notenblätter größer, und dementsprechend ging auf mehr Information drauf. Oft haben es die Notenstecher ( und denen eifert man als Lilypond-Nutzer ja nach) fertiggebracht, einen Satz auf einer Doppelseite unterzubringen, was einfach sehr praktisch ist.
Ich habe mich in der Dokumentation zu Lilypond umgesehen, ob man nicht auch eigene (beliebige, solange der Druckertreiber das unterstützt) Papierformate festlegen kann. Im Papiergroßhandel kann man sich ja auch alles Mögliche zuschneiden lassen, was dann zu so einem Format in Lilypond passen würde.
Hat jemand hier sich schon einmal mit dieser Sache beschäftigt und eventuell einen einfachen Weg gefunden in der Art wie

#(set-default-paper-size "a4")?

Statt a4 müßte man dann eben "height" und "width" in Millimetern definieren können. Oder muß man wirklich an die Eingeweide wie im folgenden Zitat:

Zitat
Extra sizes may be added by editing the definition of paper-alist in the initialization file ‘scm/paper.scm’, however they will be overridden on a subsequent install

Wenn ja, dann muß ich wohl in den sauren Apfel beißen und die Datei mal suchen gehen - hoffe, daß ich sie unter Ubuntu irgendwo finden kann. Ich bin wegen Frescobaldi für Lilypond auf Linux umgestiegen, weil das wirklich eine tolle Umgebung ist.

Ich danke Euch für Eure Anregungen und bin gespannt, was Ihr dazu zu sagen habt.


RobUr

  • Member
Re: Eigene Papierformate definieren
« Antwort #1 am: Dienstag, 19. Juli 2011, 17:23 »
Hallo juppes,

ich würde wirklich zuerst in die scm/paper.scm schauen, weil dort (ab Codezeile 110) bereits viele Papierformate definiert sind. In den Docs werden sie ja leider nicht aufgelistet …

Grüße, Robert

juppes

  • Member
Re: Eigene Papierformate definieren
« Antwort #2 am: Dienstag, 19. Juli 2011, 18:28 »
hab ich gemacht und einfach noch in der gleichen Syntax mein eigenes Format definiert (ist übrigens das Format, das Henle verwendet). Ich bekam eine Warnmeldung, daß in den Ordner nicht geschrieben werden dürfe. Dann hab ich es noch einmal mit sudo versucht, und dann ließ sich die Datei sichern. Wenn ich in meinem Lilypond-Dokument dann dieses Format global festlege:

#(set-default-paper-size "henle")
dann meckert lilypond, daß dies ein unbekanntes Format sei, und kehrt unbeirrbar zu A4 zurück. Andere Formate aus der Liste in paper.scm nimmt es ohne Murren an. Was also ist falsch?

Mein neuer Eintrag in paper.scm lautet:

("henle" . (cons (* 236 mm) (* 309 mm)))
Er steht einfach an letzter Position in der Reihe der ganzen Papierformate, die aufgezählt sind.

harm6

  • Member
Re: Eigene Papierformate definieren
« Antwort #3 am: Mittwoch, 20. Juli 2011, 00:05 »
Hallo juppes,

also ich hatte überhaupt keine Probleme Dein ("henle" . (cons (* 236 mm) (* 309 mm))) einzutragen und zu kompilieren.

Der vollständige Eintrag in paper.scm (version 2.14.1) müßte jetzt so aussehen:

(define-public paper-alist

  ;; don't use decimals.
  ;; ISO 216 has a tolerance of +- 2mm

  '(("a10" . (cons (* 26 mm) (* 37 mm)))
    ("a9" . (cons (* 37 mm) (* 52 mm)))
    ("a8" . (cons (* 52 mm) (* 74 mm)))
    ("a7" . (cons (* 74 mm) (* 105 mm)))
    ("a6" . (cons (* 105 mm) (* 148 mm)))
    ("a5" . (cons (* 148 mm) (* 210 mm)))
    ("a4" . (cons (* 210 mm) (* 297 mm)))
    ("a3" . (cons (* 297 mm) (* 420 mm)))
    ("a2" . (cons (* 420 mm) (* 594 mm)))
    ("a1" . (cons (* 594 mm) (* 841 mm)))
    ("a0" . (cons (* 841 mm) (* 1189 mm)))
    ("b10" . (cons (* 31 mm) (* 44 mm)))
    ("b9" . (cons (* 44 mm) (* 62 mm)))
    ("b8" . (cons (* 62 mm) (* 88 mm)))
    ("b7" . (cons (* 88 mm) (* 125 mm)))
    ("b6" . (cons (* 125 mm) (* 176 mm)))
    ("b5" . (cons (* 176 mm) (* 250 mm)))
    ("b4" . (cons (* 250 mm) (* 353 mm)))
    ("b3" . (cons (* 353 mm) (* 500 mm)))
    ("b2" . (cons (* 500 mm) (* 707 mm)))
    ("b1" . (cons (* 707 mm) (* 1000 mm)))
    ("b0" . (cons (* 1000 mm) (* 1414 mm)))
    ;; Below are two extended sizes defined in DIn 476
    ("4a0" . (cons (* 1682 mm) (* 2378 mm)))
    ("2a0" . (cons (* 1189 mm) (* 1682 mm)))
    ;; Below are ISO 269 standard C series
    ("c10" . (cons (* 28 mm) (* 40 mm)))
    ("c9" . (cons (* 40 mm) (* 57 mm)))
    ("c8" . (cons (* 57 mm) (* 81 mm)))
    ("c7" . (cons (* 81 mm) (* 114 mm)))
    ("c6" . (cons (* 114 mm) (* 162 mm)))
    ("c5" . (cons (* 162 mm) (* 229 mm)))
    ("c4" . (cons (* 229 mm) (* 324 mm)))
    ("c3" . (cons (* 324 mm) (* 458 mm)))
    ("c2" . (cons (* 458 mm) (* 648 mm)))
    ("c1" . (cons (* 648 mm) (* 917 mm)))
    ("c0" . (cons (* 917 mm) (* 1297 mm)))
    ;; Below are North American paper sizes
    ("legal" . (cons (* 8.5 in) (* 14.0 in)))
    ("letter" . (cons (* 8.5 in) (* 11.0 in)))
    ;; Ledger (17x11) is a 90 degree rotation of Tabloid
    ("11x17" . (cons (* 11.0 in) (* 17.0 in)))
    ;; government-letter by IEEE Printer Working Group, for children's writing
    ("government-letter" . (cons (* 8 in) (* 10.5 in)))
    ("government-legal" . (cons (* 8.5 in) (* 13.0 in)))
    ("philippine-legal" . (cons (* 8.5 in) (* 13.0 in)))
    ;; ANSI sizes
    ("ansi a" . (cons (* 8.5 in) (* 11.0 in)))
    ("ansi b" . (cons (* 17.0 in) (* 11.0 in)))
    ("ansi c" . (cons (* 17.0 in) (* 22.0 in)))
    ("ansi d" . (cons (* 22.0 in) (* 34.0 in)))
    ("ansi e" . (cons (* 34.0 in) (* 44.0 in)))
    ("engineering f" . (cons (* 28.0 in) (* 40.0 in)))
    ;; G and H are very rare, and the lengths are variable up to 90 inches
    ;; North American Architectural sizes
    ("arch a" . (cons (* 9.0 in) (* 12.0 in)))
    ("arch b" . (cons (* 12.0 in) (* 18.0 in)))
    ("arch c" . (cons (* 18.0 in) (* 24.0 in)))
    ("arch d" . (cons (* 24.0 in) (* 36.0 in)))
    ("arch e" . (cons (* 36.0 in) (* 48.0 in)))
    ("arch e1" . (cons (* 30.0 in) (* 42.0 in)))
    ;; Other sizes
    ;; Some are antique sizes which are still using in UK
    ("statement" . (cons (* 5.5 in) (* 8.5 in)))
    ("half letter" . (cons (* 5.5 in) (* 8.5 in)))
    ("quarto" . (cons (* 8.0 in) (* 10.0 in)))
    ("octavo" . (cons (* 6.75 in) (* 10.5 in)))
    ("executive" . (cons (* 7.25 in) (* 10.5 in)))
    ("monarch" . (cons (* 7.25 in) (* 10.5 in)))
    ("foolscap" . (cons (* 8.27 in) (* 13.0 in)))
    ("folio" . (cons (* 8.27 in) (* 13.0 in)))
    ("super-b" . (cons (* 13.0 in) (* 19.0 in)))
    ("post" . (cons (* 15.5 in) (* 19.5 in)))
    ("crown" . (cons (* 15.0 in) (* 20.0 in)))
    ("large post" . (cons (* 16.5 in) (* 21.0 in)))
    ("demy" . (cons (* 17.5 in) (* 22.5 in)))
    ("medium" . (cons (* 18.0 in) (* 23.0 in)))
    ("broadsheet" . (cons (* 18.0 in) (* 24.0 in)))
    ("royal" . (cons (* 20.0 in) (* 25.0 in)))
    ("elephant" . (cons (* 23.0 in) (* 28.0 in)))
    ("double demy" . (cons (* 22.5 in) (* 35.0 in)))
    ("quad demy" . (cons (* 35.0 in) (* 45.0 in)))
    ("atlas" . (cons (* 26.0 in) (* 34.0 in)))
    ("imperial" . (cons (* 22.0 in) (* 30.0 in)))
    ("antiquarian" . (cons (* 31.0 in) (* 53.0 in)))
    ;; PA4 based sizes
    ("pa0" . (cons (* 840 mm) (* 1120 mm)))
    ("pa1" . (cons (* 560 mm) (* 840 mm)))
    ("pa2" . (cons (* 420 mm) (* 560 mm)))
    ("pa3" . (cons (* 280 mm) (* 420 mm)))
    ("pa4" . (cons (* 210 mm) (* 280 mm)))
    ("pa5" . (cons (* 140 mm) (* 210 mm)))
    ("pa6" . (cons (* 105 mm) (* 140 mm)))
    ("pa7" . (cons (* 70 mm) (* 105 mm)))
    ("pa8" . (cons (* 52 mm) (* 70 mm)))
    ("pa9" . (cons (* 35 mm) (* 52 mm)))
    ("pa10" . (cons (* 26 mm) (* 35 mm)))
    ;; F4 used in southeast Asia and Australia
    ("f4" . (cons (* 210 mm) (* 330 mm)))
    ;; Used for very small @lilypond examples in the Documentation
    ;; based on a8 size but landscape not portrait
    ("a8landscape" . (cons (* 74 mm) (* 52 mm)))
    ("henle" . (cons (* 236 mm) (* 309 mm)))
    ))

Vielleicht hast Du es doch an die falsche Stelle gesetzt?

Gruß,
  Harm

juppes

  • Member
Re: Eigene Papierformate definieren
« Antwort #4 am: Mittwoch, 20. Juli 2011, 09:47 »
ja, ja, ich hatte es tatsächlich an die falsche Stelle gesetzt, aber das hat damit zu tun, daß ich mein Linux offenbar nicht recht kenne. Ich habe festgestellt, daß ich nämlich hier zwei Lilyponds auf meinem Rechner habe, die aber in zwei verschiedenen Verzeichnissen (das erste in meinem Heimatverzeichnis warum auch immer und das andere in /usr/share, wo es wohl eigentlich auch hingehört) installiert sind: 2.12.2 und 2.12.3. Da ich Frescobaldi nutze und sich Frescobaldi aber auf 2.12.2 gestürzt hat, warum auch immer, habe ich das falsche paper.scm bearbeitet! Diese ganze Situation habe ich heute morgen per Konsole überhaupt erst entdeckt. Nun habe ich das neue Format in paper.scm von Lilypond 2.12.2 eingetragen, und schon lief es bei mir auch! Ich muß mein Linux wohl mal ein bißchen aufräumen, damit ich selber besser durchblicke, aber meine Linux-Kenntnisse sind wohl noch zu rudimentär.

Danke für die Hilfe, denn jetzt geht, was ich machen wollte.

harm6

  • Member
Re: Eigene Papierformate definieren
« Antwort #5 am: Donnerstag, 21. Juli 2011, 01:45 »
Hallo juppes,

mir ist immer ein wenig unbehaglich, wenn ich in die internen Dateien eingreife. Falls ich, wie hier, nur eine Zeile hinzufüge, die nach einem Update auch noch verloren geht, so befürchte ich, daß ich nach einiger Zeit nicht mehr weiß, was ich getan habe. Anders empfinde ich, wenn ich eine ganze Datei einfüge, denn davon kann ich mir eine Sicherungskopie erstellen und später auch nachvollziehen was ich getan habe.
Insofern habe ich nach einem Weg gesucht, das Ziel eines neuen Papierformats auch mit anderen Mitteln zu erreichen.

Folgendes scheint zu funktionieren. Allerdings ist 2.14.1 erforderlich.
Ich weiß, das Du noch 2.12.2 verwendest, aber sobald Du ein update machst wird es klappen

\version "2.14.1"

#(define paper-aList
  '(
    ("a4" . (cons (* 210 mm) (* 297 mm)))
    ("henle" . (cons (* 236 mm) (* 309 mm)))
    ))       
 
#(define (setPaperDimensions m w h)
  (let*
      ((paper-default (eval-carefully
       (assoc-get
        (ly:get-option 'paper-size)
paper-aList #f #t )
       m
       (cons w h)))
       (scaleable-values `((("left-margin" . ,w) . preserve)
   (("right-margin" . ,w) . preserve)
   (("inner-margin" . ,w) . preserve)
   (("outer-margin" . ,w) . preserve)
   (("binding-offset" . ,w) . '())
   (("top-margin" . ,h) . '())
   (("bottom-margin" . ,h) . '())
   (("indent" . ,w) . '())
   (("short-indent" . ,w) . '())))
       (scaled-values
(map
         (lambda (entry)
           (let ((entry-symbol
  (string->symbol
   (string-append (caar entry) "-default")))
(orientation (cdar entry)))
     (if paper-default
(cons (if (eq? (cdr entry) 'preserve)
   (string-append (caar entry) "-default-scaled")
   (caar entry))
       (round (* orientation
(/ (eval-carefully entry-symbol m 0)
    (if (= orientation w)
(car paper-default)
(cdr paper-default))))))
entry)))
scaleable-values)))

    (module-define! m 'paper-width w)
    (module-define! m 'paper-height h)
    (module-remove! m 'line-width)

    (for-each
     (lambda (value)
       (let ((value-symbol (string->symbol (car value)))
     (number (cdr value)))
(module-define! m value-symbol number)))
     scaled-values)))
   
#(define (internalSetPaperSize module name landscape?)
  (define (swap x)
    (cons (cdr x) (car x)))

  (let* ((entry (assoc-get name paper-aList))
(is-paper? (module-defined? module 'is-paper))
(mm (eval 'mm module)))

    (cond
     ((not is-paper?)
      (ly:warning (_ "This is not a \\layout {} object, ~S") module))
     (entry

      (set! entry (eval entry module))
      (if landscape?
  (set! entry (swap entry)))
      (setPaperDimensions module (car entry) (cdr entry))

      (module-define! module 'papersizename name)
      (module-define! module 'landscape
      (if landscape? #t #f)))
     (else
      (ly:warning (_ "Unknown paper size: ~a") name)))))
     
#(define (setPaperSize name . rest)
  (if (module-defined? (current-module) 'is-paper)
      (internalSetPaperSize (current-module) name
       (memq 'landscape rest))
      (ly:warning (_ "Must use #(setPaperSize .. ) within \\paper { ... }"))))

\paper {
       
#(setPaperSize "henle")
%#(setPaperSize "henle" 'landscape)
%#(setPaperSize "a4")
%#(setPaperSize "a4" 'landscape)
 
}
   
\relative c' {
        \override Score.Stem #'details = #'(
        (lengths 4.5 3.5 3.5 4.25 5.0 6.0)
        ;(beamed-lengths 3.26 3.5 3.6)
        (beamed-minimum-free-lengths 2 1.5 1.25)
        ;(beamed-extreme-minimum-free-lengths 2.0 1.25)
        ;(stem-shorten 1.0 0.5)
        )

        <e, b' e gis d' e>2.:32 c''4:32
        c8:16 d:16 e:32 f:32 g2
        g1:32
        \repeat tremolo 2 c,16 \repeat tremolo 2 b16 \repeat tremolo 4 a32 \repeat tremolo 4 g f2
        c''8:32 b:32 a:32 g:32
        \revert Score.Stem #'details
        g2
        \once\override StemTremolo #'Y-offset = #'-1
        g1:32
}

Anmerkungen:
Alle Definitionen entstammen paper.scm und sind lediglich umbenannt, um die default-Abläufe nicht zu stören.
In der paper-aList muß neben dem neuen Format auch "a4" definiert sein, denn es wird immer mal wieder auf das default-Format verwiesen. Zusätzliche Formate könnten natürlich auch integriert werden.
Alle Formate aus paper-aList sind auch in der landscape-Variante möglich.
Diese Definitionen kann man jetzt auch in eine eigene Datei packen und \include ... benutzen.

Anwendung:

Die Angabe des Formats muß in \paper {..} mittels #(setPaperSize "...") erfolgen.

Gruß,
  Harm

RobUr

  • Member
Re: Eigene Papierformate definieren
« Antwort #6 am: Donnerstag, 21. Juli 2011, 14:01 »
Mensch Harm,

ich wusste, dass es irgendwie so gehen muss :) Irgendwas hatte ich beim ersten Rumprobieren falsch gemacht, aber hier kommt die Lösung für 2.12.3:
\version "2.12.3"

#(define-public paper-alist
  '(("henle" . (cons (* 236 mm) (* 309 mm)))
  ))

#(define (set-paper-dimensions m w h)
  "M is a module (i.e. layout->scope_ )"
  (let* ((mm (eval 'mm m)))
    (module-define! m 'paper-width w)
    (module-define! m 'paper-height h)
    (module-define! m 'line-width (- w
     (ly:modules-lookup (list m) 'left-margin (* 10 mm))
     (ly:modules-lookup (list m) 'right-margin (* 10 mm))))
    (module-define! m 'indent (/ w 14))
    (module-define! m 'short-indent 0)
    ))

#(define (internal-set-paper-size module name landscape?)
  (define (swap x)
    (cons (cdr x) (car x)))
 
  (let* ((entry (assoc name paper-alist))
(is-paper? (module-defined? module 'is-paper))
(mm (eval 'mm module)))
   
    (cond
     ((not is-paper?)
      (ly:warning (_ "This is not a \\layout {} object, ~S") module))
     ((pair? entry)

      (set! entry (eval (cdr entry) module))
      (if landscape?
  (set! entry (swap entry)))
      (set-paper-dimensions module (car entry) (cdr entry))

      (module-define! module 'papersizename name)
      (module-define! module 'landscape
      (if landscape? #t #f)))
     (else
      (ly:warning (_ "Unknown paper size: ~a") name)))))

#(define-public (set-default-paper-size name . rest)
  (internal-set-paper-size
   (ly:output-def-scope (eval '$defaultpaper (current-module)))
   name
   (memq 'landscape rest)))

#(define-public (set-paper-size name . rest)
  (if (module-defined? (current-module) 'is-paper)
      (internal-set-paper-size (current-module) name
       (memq 'landscape rest))
      (ly:warning (_ "Must use #(set-paper-size .. ) within \\paper { ... }"))))

#(define-public (scale-layout pap scale)
  (let* ((new-pap (ly:output-def-clone pap))
(dim-vars (ly:output-def-lookup pap 'dimension-variables))
(old-scope (ly:output-def-scope pap))
(scope (ly:output-def-scope new-pap)))
    (for-each
     (lambda (v)
       (let* ((var (module-variable old-scope v))
      (val (if (variable? var) (variable-ref var) #f)))
(if (number? val)
     (module-define! scope v
     (/ val scale))
     )))
     dim-vars)
    new-pap))

#(set-default-paper-size "henle")
%#(set-default-paper-size "henle" 'landscape)

Lily 2.12 meckert nicht an der fehlenden Definition von DIN A4. Die üblichen Befehle zum Einstellen des Papierformats können verwendet werden.

Für 2.14.1 ist die Lösung entsprechend:
\version "2.14.1"

#(define-public paper-alist
  '(("a4" . (cons (* 210 mm) (* 297 mm)))
    ("henle" . (cons (* 236 mm) (* 309 mm)))
  ))

#(define (set-paper-dimensions m w h)
  "M is a module (i.e. layout->scope_ )"
  (let*
      ((paper-default (eval-carefully
       (assoc-get
        (ly:get-option 'paper-size)
paper-alist
#f
#t)
       m
       (cons w h)))
       (scaleable-values `((("left-margin" . ,w) . preserve)
   (("right-margin" . ,w) . preserve)
   (("inner-margin" . ,w) . preserve)
   (("outer-margin" . ,w) . preserve)
   (("binding-offset" . ,w) . '())
   (("top-margin" . ,h) . '())
   (("bottom-margin" . ,h) . '())
   (("indent" . ,w) . '())
   (("short-indent" . ,w) . '())))
       (scaled-values
(map
         (lambda (entry)
           (let ((entry-symbol
  (string->symbol
   (string-append (caar entry) "-default")))
(orientation (cdar entry)))
     (if paper-default
(cons (if (eq? (cdr entry) 'preserve)
   (string-append (caar entry) "-default-scaled")
   (caar entry))
       (round (* orientation
(/ (eval-carefully entry-symbol m 0)
    (if (= orientation w)
(car paper-default)
(cdr paper-default))))))
entry)))
scaleable-values)))

    (module-define! m 'paper-width w)
    (module-define! m 'paper-height h)
    (module-remove! m 'line-width)

    (for-each
     (lambda (value)
       (let ((value-symbol (string->symbol (car value)))
     (number (cdr value)))
(module-define! m value-symbol number)))
     scaled-values)))

#(define (internal-set-paper-size module name landscape?)
  (define (swap x)
    (cons (cdr x) (car x)))

  (let* ((entry (assoc-get name paper-alist))
(is-paper? (module-defined? module 'is-paper))
(mm (eval 'mm module)))

    (cond
     ((not is-paper?)
      (ly:warning (_ "This is not a \\layout {} object, ~S") module))
     (entry

      (set! entry (eval entry module))
      (if landscape?
  (set! entry (swap entry)))
      (set-paper-dimensions module (car entry) (cdr entry))

      (module-define! module 'papersizename name)
      (module-define! module 'landscape
      (if landscape? #t #f)))
     (else
      (ly:warning (_ "Unknown paper size: ~a") name)))))

#(define-public (set-default-paper-size name . rest)
  (internal-set-paper-size
   (ly:output-def-scope (eval '$defaultpaper (current-module)))
   name
   (memq 'landscape rest)))

#(define-public (set-paper-size name . rest)
  (if (module-defined? (current-module) 'is-paper)
      (internal-set-paper-size (current-module) name
       (memq 'landscape rest))
      (ly:warning (_ "Must use #(set-paper-size .. ) within \\paper { ... }"))))

#(define-public (scale-layout paper scale)
  "Return a clone of the paper, scaled by the given scale factor."
  (let* ((new-paper (ly:output-def-clone paper))
(dim-vars (ly:output-def-lookup paper 'dimension-variables))
(old-scope (ly:output-def-scope paper))
(scope (ly:output-def-scope new-paper)))

    (for-each
     (lambda (v)
       (let* ((var (module-variable old-scope v))
      (val (if (variable? var) (variable-ref var) #f)))

(if (number? val)
     (module-define! scope v (/ val scale))
     )))
     dim-vars)
    (ly:output-def-set-variable! new-paper 'cloned #t)
    new-paper))

#(set-default-paper-size "henle")
%#(set-default-paper-size "henle" 'landscape)

Zitat von: harm6
Diese Definitionen kann man jetzt auch in eine eigene Datei packen und \include ... benutzen.
Was auch ich empfehle.

Viele Grüße, Robert

Enternix

  • Member
Re: Eigene Papierformate definieren
« Antwort #7 am: Montag, 3. Oktober 2011, 12:28 »
Ich habe beim selben Problem einfach die Liste paper-alist mit (sich selbst + meine eigenen Formate) ersetzt. Etwa so:

\version "2.14.2"

#(set! paper-alist (cons '("henle" . (cons (* 236 mm) (* 309 mm))) paper-alist))

\paper {
    #(set-paper-size "henle" )
}

Ich hätte damit Zugriff auf alle Standardformate plus Format "henle". Es liefe unter verschiedenen Versionen und auch den zukünftigen Versionen (vorausgesetzt, sie werden mit paper-alist implementiert). Das Kopieren der Definitionen in eine eigene Datei, oder das Verändern der Original-Datei paper.scm wäre somit unnötig.
Kann jemand prüfen, ob ich nicht einen Anfängerfehler gemacht habe?

harm6

  • Member
Re: Eigene Papierformate definieren
« Antwort #8 am: Montag, 3. Oktober 2011, 13:19 »
Hallo,

Zitat
Kann jemand prüfen, ob ich nicht einen Anfängerfehler gemacht habe?

Es handelt sich um die in diesem Fall beste Methode überhaupt!

Als der Thread gestartet wurde kannte ich diese Methode allerdings selbst noch nicht. Aber ein bißchen Vorsicht bei weiterer Verwendung dieses Befehls-Typus ist angebracht. Er wirkt für das ganze file und kann nicht so einfach rückgängig gemacht werden. Nun gibt es kein Problem bei der Setzung eigener Papierformate, aber:

Beispiel: default-script-alist aus script.scm

Wenn man hier ähnlich vorgeht um das padding für "tenuto" zu vergrößern:

#(set! default-script-alist
           (assoc-set! (assoc-ref default-script-alist "tenuto") 'padding 10.75))


so gilt das für jedes tenuto dieses file, egal wo der Befehl steht. Dieser Befehl kann nur file-weit gesetzt werden. Die einzige Möglichkeit ein einzelnes tenuto-padding, dann noch zu verändern ist das übliche \override Script #'padding = ...
(Siehe die Diskussion hierzu unter: http://old.nabble.com/placement-sostenuto-td32525088.html)

Insofern sind beide Methoden eine alist zu verändern (set! ... sowie   eigene Definitionen, die man auf welche Weise auch immer einfügt) sinnvoll. Je nach Situation ist die eine oder andere vorzuziehen.

HTH,
  Harm
« Letzte Änderung: Montag, 3. Oktober 2011, 16:14 von harm6 »