CharStyleOfPeterKahrel (Extended)

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

Print/Bildbearbeitung - Photos, Layout, Design

Themen

Beiträge

Moderatoren

Letzter Beitrag

Adobe InDesign

20971

130529

boskop, Christoph Steffens, Gerald Singelmann, Kai Rübsamen, Martin Fischer

8. Aug 2022, 13:41

Malau

1 2

Yves Apel

Beiträge gesamt: 1724

13. Dez 2006, 09:59
Beitrag # 1 von 18
Bewertung:
(21283 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 );    
}

Beste Grüße
Yves

yves-apel.eu

CharStyleOfPeterKahrel (Extended)

Martin Fischer

Beiträge gesamt: 12606

13. Dez 2006, 10:26
Beitrag # 2 von 18
Beitrag ID: #266686
Bewertung:
(21263 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen

Hallo Yves,

whow, das ist ja hammerhart. ;-)

Da wird sich mancher einer viel Tipparbeit sparen.
Danke.

Viele Grüße
Martin

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:
(21175 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: 12606

18. Dez 2006, 23:04
Beitrag # 4 von 18
Beitrag ID: #267489
Bewertung:
(21157 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.

Viele Grüße
Martin

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:
(21097 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: 12606

21. Dez 2006, 21:48
Beitrag # 6 von 18
Beitrag ID: #268027
Bewertung:
(21080 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()

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.

Viele Grüße
Martin

als Antwort auf: [#268001]

CharStyleOfPeterKahrel (Extended)

Martin Fischer

Beiträge gesamt: 12606

21. Dez 2006, 22:40
Beitrag # 7 von 18
Beitrag ID: #268032
Bewertung:
(21061 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.

Viele Grüße
Martin

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:
(21047 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: 12606

22. Dez 2006, 08:12
Beitrag # 9 von 18
Beitrag ID: #268052
Bewertung:
(21025 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.

Viele Grüße
Martin

als Antwort auf: [#268042]

CharStyleOfPeterKahrel (Extended)

Martin Fischer

Beiträge gesamt: 12606

23. Dez 2006, 19:16
Beitrag # 10 von 18
Beitrag ID: #268206
Bewertung:
(20957 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();

Viele Grüße
Martin

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:
(20700 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:
(17299 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: 12606

20. Jun 2011, 11:21
Beitrag # 13 von 18
Beitrag ID: #474033
Bewertung:
(17284 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.

Viele Grüße
Martin

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:
(17202 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:
(17187 mal gelesen)
URL zum Beitrag
Beitrag als Lesezeichen

ZUR ERGÄNZUNG:

Bitte exportieren meine ich:

Export for Digital Editions (epub)

als Antwort auf: [#474122]

1 2

Aktuell

PDF / Print

PDF 2.0 – Neu seit 2017

| 25.04.2022

Veranstaltungskalender

Hier können Sie Ihre Anlässe eintragen, welche einen Zusammenhang mit den Angeboten von HilfDirSelbst.ch wie z.B. Adobe InDesign, Photoshop, Illustrator, PDF, Pitstop, Affinity, Marketing, SEO, Büro- und Rechtsthemen etc. haben. Die Einträge werden moderiert freigeschaltet. Dies wird werktags üblicherweise innert 24 Stunden erfolgen.

Hier eine kleine Anleitung hinsichtlich Bedeutung der auszufüllenden Formularfelder.

Veranstaltungen

02.02.2023

Digitalisierung Heute

Prozesse optimieren und effizient gestalten

Zürich
Donnerstag, 02. Feb. 2023, 08.00 - 10.00 Uhr

Digitalisierung, Webauftritt

Digitalisierung mitgestalten - Worauf kommt es an? Wie wichtig ist die Webseite? Webseite mit Word Press? Interne Prozesse optimieren

Organisator: B. Isik - SNF Academy

Kontaktinformation: Birol Isik, E-Mailinfo AT bkcc DOT ch

https://digitalisierung-heute.ch/digitalisierung-informationstag-schweiz/

Veranstaltungen

01.03.2023 - 09.03.2023

Digitalisierung, SEO, WordPress

Online
Mittwoch, 01. März 2023, 00.00 Uhr - Donnerstag, 09. März 2023, 00.00 Uhr

Online Webinar

Wie gehen wir mit diesen Veränderungen um? Was ist notwendig, damit wir die Digitalisierung im Unternehmen klappt? Veränderungsprozesse verstehen und entsprechend handeln Mitarbeiter als Botschafter Webseite mit WordPress erstellen SEA /SEO (Ads aufschalten)

Organisator: B. Isik - SNF Academy

Kontaktinformation: B. Isik, E-Mailinfo AT snfa DOT ch

https://www.fernstudiumfitness.ch/digitalisierung-schweiz/

Weitere Events

Neuste Foreneinträge

app.findTextPreferences.alignToBaseline oder was in der Art

Bilder inline posten: Funktion kaputt?

Photos, Bilder im FrameMaker

Reihenfolge Endnoten bei Textboxen

Datei soll komplett ohne Grundlinienraster sein

Suche französischen Begriff

Buchfunktion, Kapitel mit ungeraden Seitenzahlen zusammenfügen

Illustrator CC2022 v26.4.0 massive Probleme / Mac

QXP Textkästen lassen iMac 5k in die Knie gehen (quälend langsam werden)

Framemaker 2020 und PDF

Weitere Stellenangebote