[Gast]  Foren Programme Print/Bildbearbeitung Adobe InDesign CharStyleOfPeterKahrel (Extended)

  • Suche
  • Hilfe
  • Lesezeichen
  • Benutzerliste
Print/Bildbearbeitung - Photos, Layout, Design
Themen
Beiträge
Moderatoren
Letzter Beitrag
Adobe InDesign
21225
132003
boskop, Christoph Steffens, Gerald Singelmann, Kai Rübsamen, Martin Fischer
19. Apr 2024, 15:02
Bernhard Werner
 

CharStyleOfPeterKahrel (Extended)

Yves Apel
Beiträge gesamt: 1724
13. Dez 2006, 09:59
Beitrag # 1 von 18
Bewertung:
(24542 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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!

Code 
// 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 );    
}

X

CharStyleOfPeterKahrel (Extended)

Martin Fischer
  
Beiträge gesamt: 12783
13. Dez 2006, 10:26
Beitrag # 2 von 18
Beitrag ID: #266686
Bewertung:
(24522 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
Hallo Yves,

whow, das ist ja hammerhart. ;-)

Da wird sich mancher einer viel Tipparbeit sparen.
Danke.

als Antwort auf: [#266684]

CharStyleOfPeterKahrel (Extended)

Wolfgang Giersberg
Beiträge gesamt: 26
18. Dez 2006, 21:14
Beitrag # 3 von 18
Beitrag ID: #267482
Bewertung:
(24434 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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“.

Code 
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

als Antwort auf: [#266686]

CharStyleOfPeterKahrel (Extended)

Martin Fischer
  
Beiträge gesamt: 12783
18. Dez 2006, 23:04
Beitrag # 4 von 18
Beitrag ID: #267489
Bewertung:
(24416 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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.

als Antwort auf: [#267482]

CharStyleOfPeterKahrel (Extended)

Wolfgang Giersberg
Beiträge gesamt: 26
21. Dez 2006, 18:47
Beitrag # 5 von 18
Beitrag ID: #268001
Bewertung:
(24356 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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:

Code 
// 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

als Antwort auf: [#267489]
(Dieser Beitrag wurde von Wolfgang Giersberg am 21. Dez 2006, 18:54 geändert)

CharStyleOfPeterKahrel (Extended)

Martin Fischer
  
Beiträge gesamt: 12783
21. Dez 2006, 21:48
Beitrag # 6 von 18
Beitrag ID: #268027
Bewertung:
(24339 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
Hallo Wolfgang,

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

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

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


kannst Du, da die Argumente vorher definiert worden sind, reduzieren auf

Code 
app.activeDocument.search()


2.
Zitat 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.

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:
Code 
// 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.
Zitat 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".

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.
Zitat Ich bin ein absoluter Anfänger, JavaScript betreffend.

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.

als Antwort auf: [#268001]

CharStyleOfPeterKahrel (Extended)

Martin Fischer
  
Beiträge gesamt: 12783
21. Dez 2006, 22:40
Beitrag # 7 von 18
Beitrag ID: #268032
Bewertung:
(24320 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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.
Code 
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.

als Antwort auf: [#268027]

CharStyleOfPeterKahrel (Extended)

Wolfgang Giersberg
Beiträge gesamt: 26
22. Dez 2006, 00:23
Beitrag # 8 von 18
Beitrag ID: #268042
Bewertung:
(24306 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
Hallo Martin,

Antwort auf [ Martin Fischer ] 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
Code 
// 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

als Antwort auf: [#268027]

CharStyleOfPeterKahrel (Extended)

Martin Fischer
  
Beiträge gesamt: 12783
22. Dez 2006, 08:12
Beitrag # 9 von 18
Beitrag ID: #268052
Bewertung:
(24284 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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:
Code 
app.changePreferences.appliedCharacterStyle = checkStyle( attributes[x] );     
app.activeDocument.search( '', false, false, '' );

Die Funktion lautet dann vollständig:
Code 
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
Code 
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:
Zitat 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.

als Antwort auf: [#268042]

CharStyleOfPeterKahrel (Extended)

Martin Fischer
  
Beiträge gesamt: 12783
23. Dez 2006, 19:16
Beitrag # 10 von 18
Beitrag ID: #268206
Bewertung:
(24216 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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 kein Zeichenformat erstellt.
- Für die anderen Schnitte der Grundschrift werden Zeichenformate mit den Namen des Schnitts erstellt.
- Für alle anderen Schriften werden Zeichenformate mit den Namen der Fonts und dem Namen des Schnitts 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.

Code 
// 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:
Code 
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:
Code 
setSpecialFonts();


als Antwort auf: [#268052]
(Dieser Beitrag wurde von Martin Fischer am 9. Mär 2007, 23:36 geändert)

CharStyleOfPeterKahrel (Extended)

Wolfgang Giersberg
Beiträge gesamt: 26
16. Jan 2007, 22:31
Beitrag # 11 von 18
Beitrag ID: #271027
Bewertung:
(23959 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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.

Code 
// 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?

als Antwort auf: [#268206]
(Dieser Beitrag wurde von Martin Fischer am 16. Jan 2007, 22:51 geändert)

CharStyleOfPeterKahrel (Extended)

PauloCoe
Beiträge gesamt: 19
20. Jun 2011, 10:49
Beitrag # 12 von 18
Beitrag ID: #474027
Bewertung:
(20558 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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

als Antwort auf: [#271027]

CharStyleOfPeterKahrel (Extended)

Martin Fischer
  
Beiträge gesamt: 12783
20. Jun 2011, 11:21
Beitrag # 13 von 18
Beitrag ID: #474033
Bewertung:
(20543 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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.

als Antwort auf: [#474027]
(Dieser Beitrag wurde von Martin Fischer am 20. Jun 2011, 11:25 geändert)

CharStyleOfPeterKahrel (Extended)

PauloCoe
Beiträge gesamt: 19
21. Jun 2011, 10:11
Beitrag # 14 von 18
Beitrag ID: #474122
Bewertung:
(20461 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
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

als Antwort auf: [#474033]

CharStyleOfPeterKahrel (Extended)

PauloCoe
Beiträge gesamt: 19
21. Jun 2011, 10:54
Beitrag # 15 von 18
Beitrag ID: #474133
Bewertung:
(20446 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen
ZUR ERGÄNZUNG:

Bitte exportieren meine ich:

Export for Digital Editions (epub)

als Antwort auf: [#474122]
X

Aktuell

PDF / Print
callas software veranstaltet Webinar rund um den Etikettendruck

| 14.12.2023

callas-Label_print_300x300
Weitere Events

Neuste Foreneinträge


Mehrfach geschichtete und übereinander gelagerte PDFs bereinigen

InDesign 19.2 konvertiert 19.3-Dateien beim Öffnen ungefragt

Platzierte Vektorgrafiken skalieren

Adobe Fonts werden nicht sofort/automatisch in ID-Dateien geladen

PDF-Formular: Dateianhang durch User?

Kontrollkästchen in PDF-Formular

Mein Tagesausflug ins Land CorelDraw

Eizo Monitorkalibrierung auf Windows

Fußnoten zu Endnoten konvertieren

SMS ab Server senden? Wie geht das?
medienjobs
Weitere Stellenangebote