Indesign Script - Vertikaler Keil nur bei bestimmten Absatzformaten

Hier eine kleine Erweiterung, bei der man den einzelnen zu berücksichtigenden AF noch eine Gewichtung für das Austreiben oben/unten mitgeben kann.

So kann man z.B. bei einem AF angeben, daß oben über das Verhältnis von Abstand oben und unten hinaus stärker gekeilt wird als unten.

Nach den geschwungenen Klammern } muß bis auf die letzte Klammer jeweils ein Komma stehen (nach der letzten Klammmer sollte keines stehen; wenn jedoch eines steht, macht da auch nichts).
Auf name: folgt der Name des AF in Anführungszeichen,
auf oben: die Gewichtung (Prozent) für den Abstand oben und
auf unten: die Gewichtung (Prozent) für den Abstand unten.

Der Normalfall für die Gewichtung sind oben und unten jeweils 100%.
Hat ein zu berücksichtigendes AF einen Abstand oben von 4 mm und unten von 2 mm wird oben und unten im Verhältnis 2:1 (proportional zum bisherigen Abstand) ausgetrieben.
Soll dieses proportionale Verhältnis aufgehoben werden und oben wie unten jeweils derselbe Wert dazuaddiert werden, dann gebe ich in dem Beispiel von oben folgende Werte ein:

Andersherum gesagt wird damit der Skalierungsfaktor oben halbiert. Unten bleibt er erhalten. Bei einem Verhältnis von 4:2 bzw. 2:1 ergibt das ein Skalierungsverhältnis von 1:1.

Das Verhältnis bleibt damit innerhalb eines AF gleich. Der Unterschied von {name:'U1', oben:200, unten:100} gegenüber {name:'U1', oben:100, unten:50} liegt im Verhältnis des Skalierungsfaktors zu anderen zu berücksichtigenden AF.

Die Definition der Gewichtung erlaubt also eine Einflußnahme in das Verhältnis von Abstand oben und unten innerhalb eines AF und in das Verhältnis gegenüber den anderen zu berücksichtigen AF.

Nochmal: Der Normalfall für die Gewichtung sind oben und unten jeweils 100%.
Zu Illustrationszwecken spiegelt die Voreinstellung im folgenden Skript nicht den Normalfall wider.

// vertikalerKeil_xxxl.jsx   
//DESCRIPTION: bringt die Abstände der Absätze proportional zu den ursrpünglichen Werten ein oder treibt sie aus, um den ausgewählten Textrahmen vertikal zu füllen. Beim Austreiben wird zusätzlich eine Gewichtung des Keils oben und unten berücksichtigt.   
// Vor dem Start des Skripts muß ein Textrahmen ausgewählt sein ( sonst läuft nix )   
   
// ===========================================   
//                     Voreinstellungen   
// ===========================================   
// zum Keilen zu berücksichtigende Absatzformate mit ihren Gewichtungen   
var myStyles = [   
    {name:'U1', oben:100, unten:100},    
    {name:'U2', oben:100, unten:100},    
    {name:'03', oben:100, unten:900}   
];    
   
var myLimit = 20 // maximaler Keilraum; wenn mehr Raum zum Keilen nötig, erscheint eine Fehlermeldung und weiter passiert nichts    
var myInfo = true; // Infokasten mit Angaben zum Keilfaktor erzeugen   
   
// ===========================================   
//                     Ende Voreinstellungen   
// ===========================================   
   
// ein Objekt ausgewählt?   
if ( app.selection.length > 0 )    
{   
    var myDoc = app.documents[0];   
    if (myInfo == true)   
    {   
        var myLayer = checkLayer( "Faktor vertikaler Keil" );   
        var myOS = checkOS( "Faktor vertikaler Keil" );   
    }   
    main( );   
}   
else    
    alert( "Welcher Textrahmen darf's denn sein?" )   
   
   
   
function main( )   
{   
    // Schleife für mehrere Objekte   
    for ( var i = 0; i < app.selection.length; i++ )   
    {   
        // ist das Objekt ein Textrahmen   
        if ( app.selection[i].constructor.name == "TextFrame" )   
                doFrame( app.selection[i] );   
        else    
            alert( "Fehler \nKeinen Textrahmen erwischt, \nsondern ( in english ) \"" + app.selection[i].constructor.name + "\"!" )   
    }   
}   
   
// -----------------------------------------------------------   
//          Abarbeitung eines Textrahmens   
// -----------------------------------------------------------   
function doFrame( myFrame )   
{   
    var myPs = myFrame.paragraphs;   
               
    // untere Textrahmenkante   
    var myPage = app.activeWindow.activePage;   
    // Wenn die untere Textrahmenkante über dem unteren Seitenrand liegt, dann ist diese die Bezugslinie zum Austreiben   
    if ( ( myFrame.geometricBounds[2] < myDoc.documentPreferences.pageHeight - myPage.marginPreferences.bottom ) )   
        var myBottom = myFrame.geometricBounds[2];   
    // Wenn die untere Textrahmenkante auf dem unteren Seitenrand oder darunter liegt,    
    // dann ist der untere Seitenrand die Bezugslinie zum Austreiben   
    else   
        var myBottom = myDoc.documentPreferences.pageHeight - myPage.marginPreferences.bottom;   
   
    // Grundlinie letzte Zeile   
	if (myFrame.lines.length > 1) 
	{ 
		var myBaseline = myFrame.lines[-1].characters[1].baseline;   
		var myDiff = myBottom - myBaseline;   
		var mySpace = getSpace ( myPs );   
		if ( ( myDiff*-1 > mySpace ) || ( myDiff > myLimit ) )   
			alert( "Sorry!\rZu wenig Raum, um den Text einzubringen. - " + myDiff );   
		else   
			doWedge( myFrame, myPs, myDiff, mySpace, myBottom );   
	} 
}   
   
// -----------------------------------------------------------   
//          zu keilenden Raum berechnen   
// -----------------------------------------------------------   
function getSpace( p )   
{   
    var aSpace = 0;   
    // Addition der Abstände VOR den Absätzen   
    // der Abstand des ersten Absatzes wird nicht berücksichtigt   
    for ( var oneP = 1; oneP < p.length; oneP++ )   
        if (checkStyle( p[oneP] ) )   
            aSpace += p[oneP].spaceBefore * checkStyle( p[oneP] ).oben/100;   
               
    // Addition der Abstände NACH den Absätzen   
    // der Abstand des letzten Absatzes wird nicht berücksichtigt   
    for ( var oneP = 0; oneP < p.length-1; oneP++ )   
        if (checkStyle( p[oneP] ) )   
            aSpace += p[oneP].spaceAfter * checkStyle( p[oneP] ).unten/100;   
       
    return aSpace;   
}   
   
// -----------------------------------------------------------   
//          Keilen   
// -----------------------------------------------------------   
function doWedge( myFrame, myPs, aDiff, aSpace, myBottom )   
{   
    // Berechnung des Zuschlagfaktors   
    var myFactor = aDiff/aSpace   
    //alert( myFactor );   
               
    // Proportionale Verteilung des zu verteilenden Raums auf die Abstände VOR den Absätzen   
    // erweitert wird nur dort, wo bereits Abstand drin ist   
    // der Abstand des ersten Absatzes wird nicht berücksichtigt   
    for ( oneP = 1; oneP < myPs.length; oneP++ )   
        if ( myPs[oneP].spaceBefore > 0 && checkStyle( myPs[oneP] ) )   
            myPs[oneP].spaceBefore += myPs[oneP].spaceBefore*myFactor*checkStyle( myPs[oneP] ).oben/100;    
   
// Proportionale Verteilung des zu verteilenden Raums auf die Abstände NACH den Absätzen   
        // erweitert wird nur dort, wo bereits Abstand drin ist   
        // der Abstand des letzten Absatzes wird nicht berücksichtigt   
    for ( oneP = 0; oneP < myPs.length-1; oneP++ )   
        if ( myPs[oneP].spaceAfter > 0  && checkStyle(myPs[oneP] ) )   
            myPs[oneP].spaceAfter += myPs[oneP].spaceAfter*myFactor*checkStyle( myPs[oneP] ).unten/100;   
   
// Setzt die untere Rahmenkante an den unteren Satzspiegelrand   
    myGB = myFrame.geometricBounds =    
        [ myFrame.geometricBounds[0],    
        myFrame.geometricBounds[1],    
        myBottom,      
        myFrame.geometricBounds[3] ];   
    if (myInfo == true)   
        makeInfo( myFactor, myFrame.parent );   
}      
   
// -----------------------------------------------------------   
//          Inforahmen für Factor erzeugen   
// -----------------------------------------------------------   
function makeInfo ( aFactor, aPage )   
{   
    // Erzeugt Inforahmen   
    myFactorFrame = aPage.textFrames.add( {   
        contents: String( aFactor ),   
        geometricBounds:[myGB[0]-4, myGB[1], myGB[0], myGB[3]],    
        itemLayer:myLayer} );   
    myFactorFrame.applyObjectStyle( myOS, true );   
}   
   
// -----------------------------------------------------------   
//          Verfügbarkeit einer Ebene prüfen   
// -----------------------------------------------------------   
function checkLayer( aName )   
{   
    try   
    {   
        theLayer = app.activeDocument.layers.item( aName ).name;   
    }   
    catch ( e )   
    {   
        theLayer = app.activeDocument.layers.add( {name:aName, visible:false} );   
    }   
    return theLayer;   
}   
   
// -----------------------------------------------------------   
//          Verfügbarkeit eines Objektstils prüfen   
// -----------------------------------------------------------   
function checkOS( aName )   
{   
    try   
    {   
        app.activeDocument.objectStyles.item( aName ).name;   
        var theOS = app.activeDocument.objectStyles.item( aName );   
    }   
    catch ( e )   
    {   
        var theOS = app.activeDocument.objectStyles.add( {name:aName} );   
    }   
    return theOS;   
}   
   
// ----------------------------------------------------------------------------------------------------------------------   
//          Prüfen, ob zugewiesenes Absatzformat in der Liste der zu berücksichtigenden AFs genannt   
// ----------------------------------------------------------------------------------------------------------------------  
function checkStyle ( aPar )   
{   
    for ( var k = 0; k < myStyles.length; k++ )   
        if ( aPar.appliedParagraphStyle.name == myStyles[k].name )   
            return myStyles[k];   
    return false;   
}

Mit einer Definition wie {name:'U1', oben:100, unten:0}, also 0 für Gewichtung unten, ist zu erreichen, daß unten nicht gekeilt wird.