CharStyleOfPeterKahrel (Extended)

Yves_Apel

Hallo zusammen,

Ich habe hier einen Kunden welcher sich für seine Projekte immer an der ganzen Schriftfamilie der Myriad bedient.

Da die Änderungen in den Absatzformaten aber gelöscht werden müssen, habe ich das "CharStyleOfPeterKahrel.js" genommen und es um alle Schriftschnitte der Myriad erweitert.

Natürlich wird nicht nur die Myriad berücksichtigt, sondern auch alle Schriften welche den selben Namen im Schriftschnitt haben (Regular, Bold, …).

Nun, wer es noch ausser mir brauchen kann, dem wünsche ich viel Spass damit!

// CharStyle Extended.jsx



//Based on the "CharStyleOfPeterKahrel.js" Script of Peter Kahrel. Thx!

attr2style( 'fontStyle = "Light Condensed"' , 'Light Condensed' );   

attr2style( 'fontStyle = "Light Condensed Italic"' , 'Light Condensed Italic' );   

attr2style( 'fontStyle = "Condensed"' , 'Condensed' );   

attr2style( 'fontStyle = "Condensed Italic"' , 'Condensed Italic' );   

attr2style( 'fontStyle = "Semibold Condensed"' , 'Semibold Condensed' );   

attr2style( 'fontStyle = "Semibold Condensed Italic"' , 'Semibold Condensed Italic' );   

attr2style( 'fontStyle = "Bold Condensed"' , 'Bold Condensed' );   

attr2style( 'fontStyle = "Bold Condensed Italic"' , 'Bold Condensed Italic' );   

attr2style( 'fontStyle = "Black Condensed"' , 'Black Condensed' );   

attr2style( 'fontStyle = "Black Condensed Italic"' , 'Black Condensed Italic' );   

attr2style( 'fontStyle = "Light SemiCondensed"' , 'Light SemiCondensed' );   

attr2style( 'fontStyle = "Light SemiCondensed Italic"' , 'Light SemiCondensed Italic' );   

attr2style( 'fontStyle = "SemiCondensed"' , 'SemiCondensed' );   

attr2style( 'fontStyle = "SemiCondensed Italic"' , 'SemiCondensed Italic' );   

attr2style( 'fontStyle = "Semibold SemiCondensed"' , 'Semibold SemiCondensed' );   

attr2style( 'fontStyle = "Semibold SemiCondensed Italic"' , 'Semibold SemiCondensed Italic' );   

attr2style( 'fontStyle = "Bold SemiCondensed"' , 'Bold SemiCondensed' );   

attr2style( 'fontStyle = "Bold SemiCondensed Italic"' , 'Bold SemiCondensed Italic' );   

attr2style( 'fontStyle = "Black SemiCondensed"' , 'Black SemiCondensed' );   

attr2style( 'fontStyle = "Black SemiCondensed Italic"' , 'Black SemiCondensed Italic' );   

attr2style( 'fontStyle = "Light"' , 'Light' );   

attr2style( 'fontStyle = "Light Italic"' , 'Light Italic' );   

//attr2style( 'fontStyle = "Regular"' , 'Regular' );   

attr2style( 'fontStyle = "Italic"' , 'Italic' );   

attr2style( 'fontStyle = "Semibold"' , 'Semibold' );   

attr2style( 'fontStyle = "Semibold Italic"' , 'Semibold Italic' );   

attr2style( 'fontStyle = "Bold"' , 'Bold' );   

attr2style( 'fontStyle = "Bold Italic"' , 'Bold Italic' );   

attr2style( 'fontStyle = "Black"' , 'Black' );   

attr2style( 'fontStyle = "Black Italic"' , 'Black Italic' );   

attr2style( 'fontStyle = "Light SemiExtended"' , 'Light SemiExtended' );   

attr2style( 'fontStyle = "Light SemiExtended Italic"' , 'Light SemiExtended Italic' );   

attr2style( 'fontStyle = "SemiExtended"' , 'SemiExtended' );   

attr2style( 'fontStyle = "SemiExtended Italic"' , 'SemiExtended Italic' );   

attr2style( 'fontStyle = "Semibold SemiExtended"' , 'Semibold SemiExtended' );   

attr2style( 'fontStyle = "Semibold SemiExtended Italic"' , 'Semibold SemiExtended Italic' );   

attr2style( 'fontStyle = "Bold SemiExtended"' , 'Bold SemiExtended' );   

attr2style( 'fontStyle = "Bold SemiExtended Italic"' , 'Bold SemiExtended Italic' );   

attr2style( 'fontStyle = "Black SemiExtended"' , 'Black SemiExtended' );   

attr2style( 'fontStyle = "Black SemiExtended Italic"' , 'Black SemiExtended Italic' );   

attr2style( 'position = Position.superscript' , 'SuperScript' );   

attr2style( 'position = Position.subscript' , 'SubScript' );   

attr2style( 'capitalization = Capitalization.smallCaps' , 'SmallCaps' );   

attr2style( 'underline = true' , 'Underline' );   

attr2style( 'strikeThru = true' , 'StrikeThru' );   

  

function attr2style( attr, st )   

{   

	app.findPreferences = app.changePreferences = null;   

	eval( 'app.findPreferences.' + attr );   

	// uncomment the following line to look for text with applied character style too (MF) 

	app.findPreferences.appliedCharacterStyle = app.activeDocument.characterStyles[0]; 

	app.changePreferences.appliedCharacterStyle = checkStyle( attr, st );   

	app.activeDocument.search( '', false, false, '' );   

}   

  

function checkStyle( attr, stylename )   

{   

	if( app.activeDocument.characterStyles.item( stylename ) == null )   

	{   

		app.activeDocument.characterStyles.add( { name : stylename } );   

		eval( 'app.activeDocument.characterStyles.item( stylename ).' + attr );   

	}   

	return app.activeDocument.characterStyles.item( stylename );   

}

Martin_Fischer

Hallo Yves,

whow, das ist ja hammerhart. ;-)

Da wird sich mancher einer viel Tipparbeit sparen.
Danke.

Wolfgang_Giersberg

Hallo zusammen,

erstmal danke für das tolle Script. Ich habe bei mir noch etwas angehängt für den Fall, dass ein Wort/Zeichen 2 Attribute hat, z.B. „hochgestellt“ und „kursiv“.

two_attr2style( 'position = Position.superscript', 'fontStyle = "Italic"', 'Superscript Italic' );

two_attr2style( 'position = Position.superscript', 'fontStyle = "Bold"', 'Superscript Bold' );

two_attr2style( 'position = Position.superscript', 'fontStyle = "Bold Italic"', 'Superscript Bold Italic' );

two_attr2style( 'position = Position.subscript', 'fontStyle = "Italic"', 'Subscript Italic' );

two_attr2style( 'position = Position.subscript', 'fontStyle = "Bold"', 'Subscript Bold' );

two_attr2style( 'position = Position.subscript', 'fontStyle = "Bold Italic"', 'Subscript Bold Italic' );

two_attr2style( 'underline = true' , 'fontStyle = "Bold Italic"' , 'Underline Bold Italic' );  

two_attr2style( 'underline = true' , 'fontStyle = "Bold"' , 'Underline Bold' );  

two_attr2style( 'underline = true' , 'fontStyle = "Italic"' , 'Underline Italic' ); 

two_attr2style( 'strikeThru = true' , 'fontStyle = "Bold Italic"' , 'StrikeThru Bold Italic' );  

two_attr2style( 'strikeThru = true' , 'fontStyle = "Bold"' , 'StrikeThru Bold' );  

two_attr2style( 'strikeThru = true' , 'fontStyle = "Italic"' , 'StrikeThru Italic' );

   

function two_attr2style( attr1, attr2, st )    

{    

	app.findPreferences = app.changePreferences = null;    

	eval( 'app.findPreferences.' + attr1 );    

	eval( 'app.findPreferences.' + attr2 ); 

	// uncomment the following line to look for text with applied character style too (MF)  

	// app.findPreferences.appliedCharacterStyle = app.activeDocument.characterStyles[0];  

	app.changePreferences.appliedCharacterStyle = two_checkStyle( attr1, attr2, st );    

	app.activeDocument.search( '', false, false, '' );    

}    

   

function two_checkStyle( attr1, attr2, stylename )    

{    

	if( app.activeDocument.characterStyles.item( stylename ) == null )    

	{    

		app.activeDocument.characterStyles.add( { name : stylename } );    

		eval( 'app.activeDocument.characterStyles.item( stylename ).' + attr1 );  

		eval( 'app.activeDocument.characterStyles.item( stylename ).' + attr2 );    

	}    

	return app.activeDocument.characterStyles.item( stylename );    

}

Das geht sicher wesentlich eleganter, aber immerhin funktioniert es. :)

Grüße
Wolfgang Giersberg

Martin_Fischer

Hallo Wolfgang,

gute Idee.
Und gute Ausführung.

Ich hatte immer ein bißchen Unbehagen wegen kombinierten Attributen.
Das kommt bei mir zwar selten vor.
Aber ab und an findet sich doch mal eine kursive Tiefstellung.

Mit Deiner Erweiterung sind diese von jetzt an gerettet.
Danke.

Wolfgang_Giersberg

So, ich habe jetzt noch weiter am Script herumgepfriemelt, weil mir die Lösung mit den hinzugefügten Funktionen nicht gefiel.

Deshalb habe ich versucht, die ganze Sache zu verallgemeinern. Herausgekommen ist das hier:

// CharStyle Extended.jsx 

 

//Based on the "CharStyleOfPeterKahrel.js" Script of Peter Kahrel. Thx! 



var zaehler=0;

attributes = new Array(); 



/***** Mehrdimensionales Array aus allen Parametern erzeugen *****/

function makeArray() 

{

	attributes[zaehler]= new Array();

	for( x = 0 ; x < arguments.length ; x++ ) 

	{

		attributes[zaehler].push( arguments[x] );

	}

	zaehler++;

}



/******************* HINWEIS **********************

*

* Der Stilname MUSS immer als erster Wert an die

* Funktion makeArray übergeben werden.

* 

* WICHTIG: Je mehr Attribute abgefragt werden, 

* desto weiter oben muss der entsprechende 

* Funktionsaufruf stehen.

* 

***************************************************/



/******* 2 Attribute abfragen *******/

makeArray( 'Superscript Italic', 'fontStyle = "Italic"', 'position = Position.superscript' );

makeArray( 'Superscript Bold', 'fontStyle = "Bold"', 'position = Position.superscript' );

makeArray( 'Superscript Bold Italic', 'position = Position.superscript', 'fontStyle = "Bold Italic"' );

makeArray( 'Subscript Italic', 'position = Position.subscript', 'fontStyle = "Italic"' );

makeArray( 'Subscript Bold', 'position = Position.subscript', 'fontStyle = "Bold"' );

makeArray( 'Subscript Bold Italic', 'position = Position.subscript', 'fontStyle = "Bold Italic"' );

makeArray( 'Underline Bold Italic', 'underline = true' , 'fontStyle = "Bold Italic"' );  

makeArray( 'Underline Bold', 'underline = true' , 'fontStyle = "Bold"' );  

makeArray( 'Underline Italic', 'underline = true' , 'fontStyle = "Italic"' ); 

makeArray( 'StrikeThru Bold Italic', 'strikeThru = true' , 'fontStyle = "Bold Italic"' );  

makeArray( 'StrikeThru Bold', 'strikeThru = true' , 'fontStyle = "Bold"' );  

makeArray( 'StrikeThru Italic', 'strikeThru = true' , 'fontStyle = "Italic"' );



/******* 1 Attribut abfragen *******/

makeArray( 'Italic', 'fontStyle = "Italic"' );

makeArray( 'Bold', 'fontStyle = "Bold"' );

makeArray( 'Light Condensed', 'fontStyle = "Light Condensed"' );    

makeArray( 'Light Condensed Italic', 'fontStyle = "Light Condensed Italic"' );    

makeArray( 'Condensed', 'fontStyle = "Condensed"' );    

makeArray( 'Condensed Italic', 'fontStyle = "Condensed Italic"' );    

makeArray( 'Semibold Condensed', 'fontStyle = "Semibold Condensed"' );    

makeArray( 'Semibold Condensed Italic', 'fontStyle = "Semibold Condensed Italic"' );    

makeArray( 'Bold Condensed', 'fontStyle = "Bold Condensed"' );    

makeArray( 'Bold Condensed Italic', 'fontStyle = "Bold Condensed Italic"' );    

makeArray( 'Black Condensed', 'fontStyle = "Black Condensed"' );    

makeArray( 'Black Condensed Italic', 'fontStyle = "Black Condensed Italic"' );    

makeArray( 'Light SemiCondensed', 'fontStyle = "Light SemiCondensed"' );    

makeArray( 'Light SemiCondensed Italic', 'fontStyle = "Light SemiCondensed Italic"' );    

makeArray( 'SemiCondensed', 'fontStyle = "SemiCondensed"' );    

makeArray( 'SemiCondensed Italic', 'fontStyle = "SemiCondensed Italic"' );    

makeArray( 'Semibold SemiCondensed', 'fontStyle = "Semibold SemiCondensed"' );    

makeArray( 'Semibold SemiCondensed Italic', 'fontStyle = "Semibold SemiCondensed Italic"' );    

makeArray( 'Bold SemiCondensed', 'fontStyle = "Bold SemiCondensed"' );    

makeArray( 'Bold SemiCondensed Italic', 'fontStyle = "Bold SemiCondensed Italic"' );    

makeArray( 'Black SemiCondensed', 'fontStyle = "Black SemiCondensed"' );    

makeArray( 'Black SemiCondensed Italic', 'fontStyle = "Black SemiCondensed Italic"' );    

makeArray( 'Light', 'fontStyle = "Light"' );    

makeArray( 'Light Italic', 'fontStyle = "Light Italic"' );    

//makeArray( 'Regular', 'fontStyle = "Regular"' );    

makeArray( 'Semibold', 'fontStyle = "Semibold"' );    

makeArray( 'Semibold Italic', 'fontStyle = "Semibold Italic"' );    

makeArray( 'Bold', 'fontStyle = "Bold"' );    

makeArray( 'Bold Italic', 'fontStyle = "Bold Italic"' );    

makeArray( 'Black', 'fontStyle = "Black"' );    

makeArray( 'Black Italic', 'fontStyle = "Black Italic"' );    

makeArray( 'Light SemiExtended', 'fontStyle = "Light SemiExtended"' );    

makeArray( 'Light SemiExtended Italic', 'fontStyle = "Light SemiExtended Italic"' );    

makeArray( 'SemiExtended', 'fontStyle = "SemiExtended"' );    

makeArray( 'SemiExtended Italic', 'fontStyle = "SemiExtended Italic"' );    

makeArray( 'Semibold SemiExtended', 'fontStyle = "Semibold SemiExtended"' );    

makeArray( 'Semibold SemiExtended Italic', 'fontStyle = "Semibold SemiExtended Italic"' );    

makeArray( 'Bold SemiExtended', 'fontStyle = "Bold SemiExtended"' );    

makeArray( 'Bold SemiExtended Italic', 'fontStyle = "Bold SemiExtended Italic"' );    

makeArray( 'Black SemiExtended', 'fontStyle = "Black SemiExtended"' );    

makeArray( 'Black SemiExtended Italic', 'fontStyle = "Black SemiExtended Italic"' );    

makeArray( 'SuperScript', 'position = Position.superscript' );    

makeArray( 'SubScript', 'position = Position.subscript' );    

makeArray( 'SmallCaps', 'capitalization = Capitalization.smallCaps' );    

makeArray( 'Underline', 'underline = true' );    

makeArray( 'StrikeThru', 'strikeThru = true' ); 





/***** Hier wird das mit makeArray erzeugte Array verarbeitet *****/

attr2style( attributes );

   

function attr2style( attributes )   

{   

	for( var x = 0 ; x < attributes.length ; x++ ) 

	{

		app.findPreferences = app.changePreferences = null;   

		for( var y = 1 ; y < attributes[x].length ; y++ ) 

		{

			eval( 'app.findPreferences.' + attributes[x][y] );

		}

		

		app.findPreferences.appliedCharacterStyle = app.activeDocument.characterStyles[0]; 

		

		app.changePreferences.appliedCharacterStyle = checkStyle( attributes[x] );   

		app.activeDocument.search( '', false, false, '' );

	}  

}   





/***** Diese Funktion arbeitet mit dem übergebenen Teilarray aus attr2style weiter ******/

function checkStyle( attributesSection )   

{   

	if( app.activeDocument.characterStyles.item( attributesSection[0] ) == null ) 

	{   

		app.activeDocument.characterStyles.add( { name : attributesSection[0] } );   

		for( var x = 1 ; x < attributesSection.length ; x++ ) 

		{

			eval( 'app.activeDocument.characterStyles.item( attributesSection[0] ).' + attributesSection[x] );

		}

	}

	return app.activeDocument.characterStyles.item( attributesSection[0] );  

}

EDIT: Variable i in x und Variable j in y umbenannt wg. Darstellungsproblemen der Forensoftware.

Es werden jetzt nur noch 3 Funktionen verwendet und die Anzahl der Suchparameter ist beliebig.

Ich frage mich übrigens, ob es möglich ist, die Zeichenformate nur dann zu erzeugen, wenn wirklich etwas entsprechendes gefunden wurde. Z.Z. erhält man ja eine gigantische Liste aus der evtl. nur 4 oder 5 Formate verwendet werden.

Interessant wäre dann noch, wo ich eine Objekt-Referenz zu ID finden kann. Ich würde z.B. gerne die Möglichkeit einbauen, nach Farben zu suchen oder nach dem Attribut "kein Umbruch".

Und noch ein HINWEIS: Ich bin ein absoluter Anfänger, JavaScript betreffend. Ich habe zwar ein paar Tests gemacht, würde aber trotzdem empfehlen, das Ding erstmal auf Testdaten loszulassen.

Grüße
Wolfgang Giersberg

Martin_Fischer

Hallo Wolfgang,

Dein Skript sieht richtig stark und effizient aus und dürfte auch dem Entwickler des Ausgangsskripts, Peter Kahrel, dem "Kompressor", gefallen.

Hier noch ein paar Anmerkungen:

1. Die Zeile
app.activeDocument.search( '', false, false, '' );
kannst Du, da die Argumente vorher definiert worden sind, reduzieren auf
app.activeDocument.search()
2.
Es ist wohl einfacher, ein unnötig erzeugtes Zeichenformat hinterher zu löschen.
Das ginge, indem Du später die Häufigkeit der Vorkommen des Zeichenformats überprüfst:
// das übergebene Zeichenformat wird in der Variable theStyle zwischengespeichert,

// da es später nochmal gebraucht wird 

var theStyle = checkStyle( attributes[x] );

app.changePreferences.appliedCharacterStyle = theStyle;    

app.activeDocument.search( '', false, false, '' ); 



// Feststellen, wie häufig das Zeichenformat vorkommt

app.findPreferences = app.changePreferences = null;    

app.findPreferences.appliedCharacterStyle = theStyle;  

if (app.activeDocument.search().length == 0)

    theStyle.remove()
Theoretisch könntest Du die Häufigkeit der Zuweisung auch bei der Zuweisung der Zeichenformate überprüfen. Aber möglicherweise ist das Zeichenformat vor Ausführung des Skripts bereits anderen Textelementen zugewiesen worden. In diesem Fall würde bei 0 neuen Zuweisungen das Zeichenformat gelöscht, obwohl es für die alte Zuweisung noch gebraucht würde.

3.

Die Scripting Reference findest Du als PDF auf einer der Installations-CDs. Sie wird standardmäßig nicht installiert. Am gleichen Ort ist ein Scripting Guide zu finden.
Darüber hinaus kannst Du Dir die Eigenschaften im Datenbrowser des ExtendScript Toolkit ansehen (ggf. eine Haltemarke setzen, um die Inhalte von Variablen vor Beendigung des Skripts zu beschauen).
Und dann gibt es noch das Script Dictionary von Peter Kahrel: http://www.kahrel.plus.com/indesignscripts.html

4.

Oh, ein Skriptmeister, der vom Himmel gefallen ist.
Wenn das schon so anfängt, dann können wir uns noch auf 'was gefaßt machen. ;-)
Klasse Leistung!
Und schau mal ins Adobe InDesign Scripting Forum. Dort kann man so jemanden wie Dich gut gebrauchen. Und dort gibt es auch noch einiges von den Skripting-Akrobaten zu lernen.

Martin_Fischer

Hallo Wolfgang,

eine weitere Anregung:

Um unnötige Suchläufe nach Schriftschnitten zu verhindern, die im Dokument gar nicht vorhanden sind, könntest Du auch noch eine Abfrage nach den im Dokument verwendeten Schriftschnitten einbinden und diese mit den anderen Stilkombinationen (unterstrichen, durchgestrichen, Kapitälchen, hoch-/tiefgestellt ...) verwursteln.


var thePresentFontStyles = app.activeDocument.fonts.everyItem().fontStyleName;

Und noch eins:
Manchmal wäre es auch notwendig, Schriften, die von der Basisschrift (Standardschrift im Basis-Absatzformat; ggf. per DropDown-Auswahlmenü zu bestimmen) abweichen, in einem Zeichenformat einzufrieren.
Z.B. Symbolschriften oder Fremdalphabete (Arabisch, Griechisch, Hebräisch, Koptisch, Syrisch ...).
Und das in verschiedenen Schnitten ...

Man könnte dieses Skript zu einer eierlegenden Wollmilchsau für das Einfrieren von besonderen Zeichenformatierungen aufblähen.

Wolfgang_Giersberg

Hallo Martin,

Antwort auf:
Oh, ein Skriptmeister, der vom Himmel gefallen ist.

Danke für die Blumen. :) Und für die sehr interessanten Anregungen. Aber zum Meister reicht es dann doch noch nicht. Da muss ich mich erst noch wesentlich tiefer in die Sprache, die ID-Objekte und die Objektorientierung im allgemeinen einlesen (ansonsten skripte ich seit etwa einem Jahr sporadisch mit PHP ohne OOP).

So bin ich mir z.B. nicht sicher, wo ich das hier

// das übergebene Zeichenformat wird in der Variable theStyle zwischengespeichert, 

// da es später nochmal gebraucht wird  

var theStyle = checkStyle( attributes[x] ); 

app.changePreferences.appliedCharacterStyle = theStyle;     

app.activeDocument.search( '', false, false, '' );  

 

// Feststellen, wie häufig das Zeichenformat vorkommt 

app.findPreferences = app.changePreferences = null;     

app.findPreferences.appliedCharacterStyle = theStyle;   

if (app.activeDocument.search().length == 0) 

    theStyle.remove()

einfügen soll. Hättest Du da einen kleinen Hinweis für mich. Hier zeigt sich die mangelnde Kenntnis der Sprache. Ich verstehe zwar die Logik der Aufbereitung (wäre in PHP ungefähr identisch), aber woher die Daten kommen und wohin sie zum Schluss gehen erschließt sich derzeit nur in Bruchstücken.

Werde mich jetzt mal auf die Suche nach meinen CDs machen und die Referenz und den Guide durchlesen.

Grüße
Wolfgang

Martin_Fischer

Hallo Wolfgang,

> So bin ich mir z.B. nicht sicher, wo ich das hier (...) einfügen soll.

Die genannten Zeilen ersetzen/erweitern folgende Zeilen aus Deiner Version:

app.changePreferences.appliedCharacterStyle = checkStyle( attributes[x] );    

app.activeDocument.search( '', false, false, '' );

Die Funktion lautet dann vollständig:

function attr2style( attributes )    

{    

	for( var x = 0 ; x < attributes.length ; x++ )  

	{ 

		app.findPreferences = app.changePreferences = null;    

		for( var y = 1 ; y < attributes[x].length ; y++ )  

		{ 

			eval( 'app.findPreferences.' + attributes[x][y] ); 

		} 

		 

		app.findPreferences.appliedCharacterStyle = app.activeDocument.characterStyles[0];  

		 

		// das übergebene Zeichenformat wird in der Variable theStyle zwischengespeichert,

		// da es später nochmal gebraucht wird 

		var theStyle = checkStyle( attributes[x] );

		app.changePreferences.appliedCharacterStyle = theStyle;    

		app.activeDocument.search( '', false, false, '' ); 



		// Feststellen, wie häufig das Zeichenformat vorkommt

		app.findPreferences = app.changePreferences = null;    

		app.findPreferences.appliedCharacterStyle = theStyle;  

		if (app.activeDocument.search().length == 0)

		    theStyle.remove()

	} 

}

Der zweite Block, in dem ggf. das Löschen des Zeichenformats erfolgt, wäre vielleicht besser in einer Unterfunktion untergebracht. Ich wollte hier in der Diskussion nicht zu sehr in den vorhandenen Code eingreifen.

Alternativ könnte man die Reduktion von überflüssig erzeugten Zeichenformat auch folgendermaßen lösen:
1. Wenn ein Zeichenformat neu erzeugt wird, dann bekommt es in der checkStyle()-Funktion ein flag (eine weitere boolsche Variable "theCharStyleCreated", die standardmäßig auf false initialisiert ist, wird auf true gesetzt);

2. aus "app.activeDocument.search( '', false, false, '' );" wird

var theResult = app.activeDocument.search( '', false, false, '' );

3. dann kann über eine Abfrage "if (theCharStyleCreated && (theResult.length == 0))" entschieden werden, ob das neu erzeugte Zeichenformat, das nirgends zugewiesen worden ist, wieder gelöscht wird.

Über dieses Verfahren könnte man sich das im obigen Schnipsel eingebundene nochmalige Suchen nach dem Vorkommen des Absatzformats sparen und das Skript damit beschleunigen.
Darüberhinaus wäre sichergestellt, daß nur solche Zeichenformat gelöscht werden, die während der Ausführung des Skripts erzeugt und für unnötig befunden werden.
Andere, vor Start des Skripts existierende Zeichenformate, blieben unberührt. Auch wenn sie im Moment vom Dokument nicht gebraucht werden (also keinem Text zugewiesen sind).

Im Übrigen muß ich meine Aussage von oben widerrufen:

1. Die Zeile
app.activeDocument.search( '', false, false, '' );
kannst Du, da die Argumente vorher definiert worden sind, reduzieren auf
app.activeDocument.search();

Die beiden Zeilen führen tatsächlich zu unterschiedlichen Ergebnissen.
Die Kurzfassung führt den eigentlichen Ersetzevorgang nämlich gar nicht aus.
Der Grund dafür fällt mir grad nicht ein, sind doch alle notwendigen Suche-/Ersetze-Parameter über die app.findPreferences und die app.changePreferences definiert.

Martin_Fischer

Nun hat's mir doch selber in den Fingern gejuckt und ich habe mir unter Einbezug von Wolfgangs komfortablen Funktionen ein Skript zusammengebastelt, das alle im Dokument verwendeten Schriften mit ihren Schnitten in Zeichenformate einfriert.

- Für die Grundschrift selbst, die aus einem Basisabsatzformat ermittelt wird, wird [red]kein Zeichenformat[/red] erstellt.
- Für die anderen Schnitte der Grundschrift werden [red]Zeichenformate mit den Namen des Schnitts[/red] erstellt.
- Für alle anderen Schriften werden [red]Zeichenformate mit den Namen der Fonts und dem Namen des Schnitts[/red] erstellt.

Beispiel:
Grundschrift = Times New Roman - Regular.
Für diese Grundschrift wird keine Zeichenformat erstellt.
Für den Kursivschnitt der Grundschrift wird (wenn im Dokument vorhanden) ein Zeichenformat "Italic" erstellt. Dasselbe gilt für den fetten Schnitt und für Bold-Italic.

Nehmen wir an, es werden im Dokument auch die Myriad Pro - Regular und Italic verwendet.
Dann werden die Zeichenformate "Myriad Pro-Regular" und "Myriad Pro-Italic" erstellt und zugewiesen.

Ein Problem mit nicht aktiven Schriften konnte ich nicht lösen:
Wird im Dokument eine Schrift verwendet, die nicht aktiv/vorhanden ist, kann diese (anders als im Suchen-Dialog der graphischen Benutzeroberfläche) über die Suchfunktion im Skript nicht gesucht werden. Diese Schriften, die damit also nicht in ein Zeichenformat eingefroren werden können, werden ggf. am Ende des Skripts in einem Dialogfenster angezeigt.

Eine kleine Überraschung:
Das o.g. Problem gibt es nicht, wenn eine aktive Schrift mit einem inaktiven Schnitt verwendet worden ist. Da wird ein Zeichenformat angelegt und zugewiesen.


// charStyles4SpecialFonts.jsx   

 

var myDoc =  app.activeDocument; 

var zaehler=0;  

missingFonts = new Array(); 

attributes = new Array();   

  

setSpecialFonts(); 

attr2style(attributes);  

if (missingFonts.length == 0) { 

	alert("Fix und fertig!"); 

} 

else { 

	alert("Kein Zeichenformat für folgende fehlende Schriften: \r" + missingFonts.join("\r")); 

} 

     

/***** Schriftschnittformate für Grundschrift und Font-Formate für andere Schriften *****/  

function setSpecialFonts() { 

	var thePresentFonts =myDoc.fonts;  

	var theBaseParaStyle = prompt("Basisabsatzformat", myDoc.paragraphStyles[2].name); 

	//var theBaseParaStyle = myDoc.paragraphStyles[2].name; 

	 

	if(app.activeDocument.paragraphStyles.item(theBaseParaStyle) == null) { 

		alert ("Fehler\rDas Absatzformat \"" + theBaseParaStyle + "\" existiert nicht."); 

		exit(); 

		//return; 

	} 

	for (var i = 0; i < thePresentFonts.length; i++) { 

		if (thePresentFonts[.i].name != myDoc.paragraphStyles.item(theBaseParaStyle).appliedFont.name) { 

			if (thePresentFonts[.i].fontFamily != myDoc.paragraphStyles.item(theBaseParaStyle).appliedFont.fontFamily) { 

				makeArray(thePresentFonts[.i].name.split("\t").join("-"),  'appliedFont = "' + thePresentFonts[.i].name + '"');  

			} 

			else { 

				makeArray(thePresentFonts[.i].fontStyleName,  'appliedFont = "' + thePresentFonts[.i].name + '"'); 			 

			} 

		} 

	} 

} 

 

/***** Mehrdimensionales Array aus allen Parametern erzeugen *****/  

function makeArray()  {  

	attributes[zaehler]= new Array();  

	for (var x = 0; x < arguments.length; x++)   

		attributes[zaehler].push(arguments[x]);  

	zaehler++;  

}  

   

/***** Hier wird das mit makeArray erzeugte Array verarbeitet *****/  

function attr2style(attributes) {     

	for (var x = 0; x < attributes.length; x++)  {  

		app.findPreferences = app.changePreferences = null;     

		for (var y = 1; y < attributes[x].length; y++) {  

			try { 

				eval('app.findPreferences.' + attributes[x][y]);  

				// nur Formatierung ohne zugewiesenes Zeichenformat suchen 

				app.findPreferences.appliedCharacterStyle = app.activeDocument.characterStyles[0];   

		  

				app.changePreferences.appliedCharacterStyle = checkStyle(attributes[x]);   

				app.activeDocument.search('', false, false, '');  

			} 

			catch(e) { 

				missingFonts.push(attributes[x][0]); 

			} 

		} 		  

	}  

}     

  

  

/***** Diese Funktion arbeitet mit dem übergebenen Teilarray aus attr2style weiter ******/  

function checkStyle(attributesSection)  {     

	if (app.activeDocument.characterStyles.item(attributesSection[0]) == null) {     

		app.activeDocument.characterStyles.add({ name : attributesSection[0] });     

		for (var x = 1; x < attributesSection.length; x++)   

			eval('app.activeDocument.characterStyles.item(attributesSection[0]).' + attributesSection[x]);  

	}  

	return app.activeDocument.characterStyles.item(attributesSection[0]);    

}

Andere Zeichenattribute (unterstrichen, hoch-/tiefgestellt, Kapitälchen ...) bleiben von diesem Skript unberücksichtigt. Sie können aus dem Baukasten von Wolfgang leicht nachträglich nach eigenem Bedarf zusammengestellt und eingefügt werden.

Beispiel:


makeArray( 'SuperScript', 'position = Position.superscript' );     

makeArray( 'SubScript', 'position = Position.subscript' );     

makeArray( 'SmallCaps', 'capitalization = Capitalization.smallCaps' );

Dieser Block wäre direkt vor oder nach der folgenden Zeile einzufügen:

setSpecialFonts();

Wolfgang_Giersberg

Hallihallo,

habe auch mal wieder ein bißchen dran geschraubt:

Das Ding hat jetzt erst eine Abfrage nach dem Basisformat und zeigt im nächsten Schritt einen Dialog an, in dem man die Abweichungen auswählen kann, die man einfrieren will.

"Hochgestellt" u.ä. bzw. Farben werden bisher noch nicht berücksichtigt.


// charStyles4SpecialFonts extended.jsx   

  

var myDoc = app.activeDocument;  

var zaehler=0;  

missingFonts = new Array();  

attributes = new Array(); 

  

setSpecialFonts();  

attr2style( attributes );  

if ( missingFonts.length == 0 ) {  

	alert( "Fix und fertig!" );  

}  

else {  

	alert( "Kein Zeichenformat für folgende fehlende Schriften: \r" + missingFonts.join( "\r" ) );  

}  

    

/***** Schriftschnittformate für Grundschrift und Font-Formate für andere Schriften *****/  

function setSpecialFonts()  

{  

	var thePresentFonts = myDoc.fonts;  

	 

	//Dialogfeld zur Basisformatauswahl erstellen 

	var myBaseParaDialog = app.dialogs.add( {name:"Basisformat auswählen" , canCancel:true} ); 

	with( myBaseParaDialog ) 

	{ 

		//Dialogspalte hinzufügen. 

		with( dialogColumns.add() ) 

		{ 

			//Bereich erstellen. 

			with( borderPanels.add() ) 

			{ 

				with( dialogColumns.add() ) 

				{ 

				//Die folgende Zeile zeigt, wie beim Erstellen eines Objekts eine Eigenschaft eingestellt wird. 

				staticTexts.add( {staticLabel:"Basisabsatzformat:"} ); 

				} 

				with( dialogColumns.add() ) 

				{ 

				//Die folgende Zeile zeigt, wie beim Erstellen eines Objekts mehrere Eigenschaften eingestellt werden. 

				var theBaseParaStyleField = textEditboxes.add( {editContents:"", minWidth:180} ); 

				} 

			} 

		} 

	} 

		 

	//var theBaseParaStyle = prompt( "Basisabsatzformat", myDoc.paragraphStyles[2].name );  

	//var theBaseParaStyle = myDoc.paragraphStyles[2].name;  

	 

	//Dialogfeld zur Basisformatauswahl anzeigen. 

	var myResult = myBaseParaDialog.show(); 

	if( myResult == true ) 

	{ 

		//Werte aus den Steuerelementen des Dialogfelds abrufen. 

		var theBaseParaStyle = theBaseParaStyleField.editContents; 

		//Dialogfeld aus dem Arbeitsspeicher entfernen. 

		myBaseParaDialog.destroy(); 

	} 

	else 

	{ 

		//Anwender hat auf "Abbrechen" geklickt, Dialogfeld daher aus dem Arbeitsspeicher entfernen. 

		myBaseParaDialog.destroy(); 

		exit(); 

	} 

	 

	if( theBaseParaStyle == '' ) 

	{ 

		alert( "Es wurde kein Basisabsatzformat gewählt!" ); 

		exit(); 

	} 

	 

	if( app.activeDocument.paragraphStyles.item( theBaseParaStyle ) == null )  

	{  

		alert ( "Fehler\rDas Absatzformat \"" + theBaseParaStyle + "\" existiert nicht." );  

		exit();  

		//return;  

	}  

	 

	//Dialog zur Schriftauswahl erstellen 

	var myFontsDialog = app.dialogs.add( {name:"Schriften und Stile auswählen" , canCancel:true} ); 

	with( myFontsDialog ) 

	{	 

		//Dialogspalte hinzufügen. 

		var myFontColumn = dialogColumns.add() 

		with( myFontColumn ) 

		{ 

			//Bereich erstellen. 

			 

				//Die folgende Zeile zeigt, wie beim Erstellen eines Objekts eine Eigenschaft eingestellt wird. 

				staticTexts.add( {staticLabel:"Schriften, die nicht dem Basisformat entsprechen:"} ); 

				var fontCounter = 0; 

				 

				/*var myFontRow = dialogRows.add(); 

				with( myFontRow ) 

				{*/ 

					for ( var i = 0; i < thePresentFonts.length; i++ ) 

					{ 

						if ( thePresentFonts[.i].name != myDoc.paragraphStyles.item( theBaseParaStyle ).appliedFont.name )  

						{  

							if ( thePresentFonts[.i].fontFamily != myDoc.paragraphStyles.item( theBaseParaStyle ).appliedFont.fontFamily )  

							{  

								checkboxControls.add( {staticLabel:thePresentFonts[.i].name.split( "\t" ).join( "-" )} ); 

								fontCounter ++;  

							}  

						} 	 

					} 

					if( fontCounter == 0 ) 

					{ 

						staticTexts.add( {staticStLabel:"Keine abweichenden Schriften vorhanden."} ); 

					} 

				//} 

			 

			 

				 

				//Die folgende Zeile zeigt, wie beim Erstellen eines Objekts eine Eigenschaft eingestellt wird. 

				staticTexts.add( {staticLabel:"Schnitte der Basisschrift ("+ myDoc.paragraphStyles.item( theBaseParaStyle ).appliedFont.fontFamily + "):"} ); 

				var styleCounter = 0;				 

				/*myStyleRow = dialogRows.add(); 

				with( myStyleRow ) 

				{*/ 

				for ( var i = 0; i < thePresentFonts.length; i++ ) 

				{ 

					if ( thePresentFonts[.i].name != myDoc.paragraphStyles.item( theBaseParaStyle ).appliedFont.name )  

					{  

						if ( thePresentFonts[.i].fontFamily == myDoc.paragraphStyles.item( theBaseParaStyle ).appliedFont.fontFamily )  

						{  

							checkboxControls.add( {staticLabel:thePresentFonts[.i].name.split( "\t" ).join( "-" )} ); 

							styleCounter ++;	  

						}  

					} 	 

				} 

				if( styleCounter == 0 ) 

				{ 

					staticTexts.add( {staticLabel:"Keine abweichenden Schnitte vorhanden."} ); 

				} 

				//} 

					 

		} 

	}  

	 

	//Dialogfeld zur Schriftauswahl anzeigen. 

	//Werte des Dialogfelds abrufen. 

	var myResult = myFontsDialog.show(); 

	if( myResult == true ) 

	{ 

		for ( var i = 0; i < myFontColumn.checkboxControls.length; i++ )  

		{  

			if ( myFontColumn.checkboxControls.item(i).checkedState == true ) 

			{ 

				if ( myFontColumn.checkboxControls.item(i).staticLabel != myDoc.paragraphStyles.item( theBaseParaStyle ).appliedFont.name )  

				{  

					var theFullFontName = myFontColumn.checkboxControls.item(i).staticLabel.split( "-" ).join( "\t" ); 

					var theFontName = myFontColumn.checkboxControls.item(i).staticLabel.split( "-" ); 

					 

					if ( theFontName[0] != myDoc.paragraphStyles.item( theBaseParaStyle ).appliedFont.fontFamily )  

					{  

						makeArray( myFontColumn.checkboxControls.item(i).staticLabel,  'appliedFont = "' + theFullFontName + '"' );  

					}  

					if ( theFontName[0] == myDoc.paragraphStyles.item( theBaseParaStyle ).appliedFont.fontFamily ) 

					{  

						makeArray( theFontName[1], 'fontStyle = "' + theFontName[1] + '"' ); 			  

					}  

				} 

			}  

		} 

 

		//var theBaseParaStyle = theBaseParaStyleField.editContents; 

		//Dialogfeld aus dem Arbeitsspeicher entfernen. 

		myFontsDialog.destroy(); 

	} 

	else 

	{ 

		//Anwender hat auf "Abbrechen" geklickt, Dialogfeld daher aus dem Arbeitsspeicher entfernen. 

		myFontsDialog.destroy(); 

		exit(); 

	} 

	 

	 

}  

  

/***** Mehrdimensionales Array aus allen Parametern erzeugen *****/  

function makeArray() {  

	attributes[zaehler]= new Array();  

	for ( var x = 0; x < arguments.length; x++ )   

		attributes[zaehler].push( arguments[x] );  

	zaehler++;  

}  

   

/***** Hier wird das mit makeArray erzeugte Array verarbeitet *****/  

function attr2style( attributes )  

{    

	for ( var x = 0; x < attributes.length; x++ )  

	{  

		app.findPreferences = app.changePreferences = null;    

		for ( var y = 1; y < attributes[x].length; y++ )  

		{  

			try  

			{  

				eval( 'app.findPreferences.' + attributes[x][y] );  

				// nur Formatierung ohne zugewiesenes Zeichenformat suchen  

				app.findPreferences.appliedCharacterStyle = app.activeDocument.characterStyles[0];   

		  

				app.changePreferences.appliedCharacterStyle = checkStyle( attributes[x] );   

				app.activeDocument.search( '', false, false, '' );  

			}  

			catch( e ) {  

				missingFonts.push( attributes[x][0] );  

			}  

		} 		  

	}  

}    

  

  

/***** Diese Funktion arbeitet mit dem übergebenen Teilarray aus attr2style weiter ******/  

function checkStyle( attributesSection )  

{    

	if ( app.activeDocument.characterStyles.item( attributesSection[0] ) == null )  

	{    

		app.activeDocument.characterStyles.add( { name : attributesSection[0] } );    

		for ( var x = 1; x < attributesSection.length; x++ )   

			eval( 'app.activeDocument.characterStyles.item( attributesSection[0] ).' + attributesSection[x] );  

	}  

	return app.activeDocument.characterStyles.item( attributesSection[0] );   

}

Mein Code erscheint mir ziemlich umständlich. Wenn also jemand Verbesserungsvorschläge hat - immer her damit.

Hätte das Script lieber als .zip angehängt. Gibt es auf dieser Welt eigentlich irgendwas, was kein Geld kostet ... ?

Edit: Da fällt mir noch ein: Das Kommando /r scheint in Dialogfeldern nichts zu bewirken. Also etwas wie "Schriftformate:/rFormat/rFormat/rFormat" steht im Dialogfeld in einer Zeile. /n geht auch nicht. Weiß da jemand genaueres?

PauloCoe

Hallo

Habe es nun bereits mit verschiedenen CharStyle-Scripts in InDesign versucht. Doch leider erhalte ich immer die gleiche Fehlermeldung:

JavaScript !
Error:
File:/User/..../Library/Preferences/Adobe InDesing/Version 6.0/en_US/Scripts/Scripts Panel/CharStyle
Line: 16
Source: app.findPreferences =
app.changePreferences = null;

Da ich keine Ahnung von Skripts habe wäre ich frohn wenn mir jemande von Euch helfen könnte.

Übrigens, bei dem Skript von Wolfgang erhalte ich keine solche Meldung, dafür bin ich dort überfordert wenn ich aufgefordert
werde das Basisabsatzformat zu wählen.

Ihr seht ich habe echt keine Ahnung. Wäre froh wenn ich hier Hilfe finden würde.

Beste Grüsse
Paulo

Martin_Fischer

Hallo Paulo,

Du verwendest eine InDesign-Version größer 4 (bzw. größer CS2), nämlich InDesign 6 (CS4). Die von Dir zitierten Zeilen stammen aus einem Skript für CS2.

Versuch's mal mit TextStyle2charStyle.jsx.

PauloCoe

Hallo Martin

Vielen lieben Dank für deine rasche Hilfe. Super!
Das hat soweit funktioniert.

Nun habe ich allerdings noch das Problem, dass ich einige Wörter komplett in GROSSBUCHSTABEN geschrieben habe. Dieses Format wird aber leider nicht exportiert.

Ist dies überhaupt möglich oder müsste ich dafür ebenfalls einen CharacterStyle haben?

Ich dreh am Rad...

Gruss
Paulo

PauloCoe

ZUR ERGÄNZUNG:

Bitte exportieren meine ich:

Export for Digital Editions (epub)

PauloCoe

habs nun herausgefunden, warum beim export in epub die wörter welche ich komplett mit GROSSBUCHSTABEN geschrieben habe, im EBook klein dargestellt werden.

Die Wörter wurden im InDesign nicht effektiv GROSS geschrieben sonder über Format GROSS gemacht.

Komme also wohl nicht drum herum die Wörter nochmals zu schreiben.

Uwe_Laubender

Antwort auf: Komme also wohl nicht drum herum die Wörter nochmals zu schreiben.

Hallo!
Nein. Brauchst Du nicht, wenn Du das Script grep_change_case.jsx von Peter Kahrel einsetzt. Anleitung und Download gibt's hier:

http://www.kahrel.plus.com/indesign/grep_change_case.html

[#707070]MacBook Pro 2.4GHz | OS X 10.5.8 | Adobe CS3/CS4/CS5/CS5.5 Design Premium[/#]

PauloCoe

Salut

Tausen Dank! Damit hast du mir geholfen ne Menge Zeit einzusparen. Funktioniert wunderbar.

Gruss
Paulo