ExtendScript Support

Generate a Unique File Name

2010-05-17T12:41:00.001-04:00

Uses Two Other generic functions

This is a useful function to generate a unique file name. If the File object it is passed already exists then this function adds an underscore and a number from 02 to 99 to the base name of the file until it finds a unique file name. If no unique name can be generated, it returns null.

This function calls two other previously posted functions. The first determines the base name, or the name without the extension. The second pads a number to fill out a specified number of digits.

function uniqueFile (fileRef) {

//-------------------------------------------------------------------------

//-- U N I Q U E F I L E

//-------------------------------------------------------------------------

//-- Generic: Yes, for ExtendScript CS3 and newer

//-------------------------------------------------------------------------

//-- Purpose: To take a FileRef and check to see if it is unique. If yes,

//-- then return it, else add a suffix starting with _02 and keep trying

//-- until it is unique

//-------------------------------------------------------------------------

//-- Arguments: fileRef: a File object

//-------------------------------------------------------------------------

//-- Calls: Custom File method .nameWithoutExtension()

//-- Calls: pad

//-------------------------------------------------------------------------

//-- Returns: a File object. It might be the same one. If the function

//-- fails it returns null

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var u = uniqueFileName (File ('~/Sample.txt' )) ;

//~ if (u != null) {

//~ //-- use the file here

//~ }

//-------------------------------------------------------------------------

//-- Written: 2010.05.02 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Do quick initial test. If the file is already unique then return it.

if (! fileRef.exists) {

return fileRef ;

}

//-- File isn't unique, get all the parts to construct a new one

var container = fileRef.parent ;

var baseName = fileRef.nameWithoutExtension() ;

var extension = fileRef.name.substr(baseName.length) ;

//-- Loop until reaching a unique file, then return it.

for (var version = 2; 99 >= version; version++) {

var uniqueTest = File (container + '/' + baseName + '_' + pad (version, 2, 0) + extension) ;

if (! uniqueTest.exists) {

return uniqueTest ;

}

//-- Unable to come up with a unique file, so return null

return null ;

}

CS4 to CS5 Changes

2010-05-14T22:13:00.003-04:00

Noticed Changes

Just getting started with CS5 and encountering a few changes.

.lockState

Interesting is that that the .lockState property has been removed from Text Frames. Well Text Frames and a few other items. I suppose that since it is the story of the frame that is locked it makes sense, but why the change now?

.checkIn () & .checkOut ()

Similar to the .lockState, the .checkIn and .checkOut methods have been moved to the story. The easy fix in all of these cases is to insert .parentStory in front of .lockState or .checkOut() or .checkIn().

Paragraphs of Selection

2010-05-10T10:04:00.002-04:00

Handy for certain tasks

This is another function that I tend to use when needing to work with paragraphs. I recently came across it again and thought it was fine time to share.

The basic premise is that if the user has some text selected and you want to automate something with regard to the whole paragraphs that have any part selected, then you need something like this.

With all the ifs, switches, etc., this code sure does go marching off to the right, but that is just the way it is. It doesn't have to be pretty, it just has to work.

Comments?

function getParagraphsOfSelection () {

//----------------------------------------------------------------------------

//-- G E T P A R A G R A P H S O F S E L E C T I O N

//----------------------------------------------------------------------------

//-- Generic: Yes.

//----------------------------------------------------------------------------

//-- Purpose: To return an array of paragraphs relating to the selection

//-- or false if there is no selection or an error.

//----------------------------------------------------------------------------

//-- Written: 10 March 2009 by Jon S. Winters from a prior work.

//-- eps@electronicpublishingsupport.com

//----------------------------------------------------------------------------

//-- Determine is there in an appropriate selection.

try {

//-- Initialize the object

var myObject = false ;

//-- Check for a selection.

if(app.documents.length != 0){

if(app.selection.length != 0){

//Process the objects in the selection to create a list of

//qualifying objects (text frames).

switch(app.selection[0].constructor.name){

case "TextFrame":

myObject = ( app.selection[0].parentStory.paragraphs ) ;

break;

default:

if(app.selection.length == 1){

//If text is selected, then get the parent text frame.

switch(app.selection[0].constructor.name){

case "Text":

case "InsertionPoint":

case "Character":

case "Word":

case "Line":

case "TextStyleRange":

case "Paragraph":

case "TextColumn":

myObject = ( app.selection[0].paragraphs );

break;

} //-- end of switch

} //-- end of if selections == 1

break;

} //-- end of switch

} //-- end of app.selection.length

} //-- end of app.documents.length

} //-- end of try

catch (caughtError) {

return {} ;

}

return myObject ;

}//-- End of function

Insert Glyph

2010-05-03T09:54:00.002-04:00

Method to insert additional special characters

A client has been asking me for create an extension of Adobe InCopy and Adobe InDesign's Insert Special Character submenus. This blog already has code posted to create menu items with keyboard shortcuts. The code below actually inserts a glyph at the current insertion point. This code takes a slightly different approach than the Insert Special Characters in that it will not replace as selection, it only works when there is an insertion point.

What is interesting is that it is driven by the same Unicode text that the Info Panel displays when the desired glyph is selected in a story. So to insert a 1/4 fraction glyph you would use:

insertGlyph ('0xBC') ;

That unicode number is internally converted to a different encoding by replacing the 0x with a %u and adding any necessary leading zeros before being unencoded and forced to be a string. There is far more error checking than actual code.

function insertGlyph (charCodeOfGlyphToInsert) {

//-------------------------------------------------------------------------

//-- I N S E R T G L Y P H

//-------------------------------------------------------------------------

//-- Generic: Yes for Adobe InDesign and Adobe InCopy CS3 and newer

//-------------------------------------------------------------------------

//-- Purpose: To take a code for a glyph as listed by the Info panel and

//-- insert the the glyph at the insertion point if there is an insertion

//-- point.

//-------------------------------------------------------------------------

//-- Arguments:

//-- charCodeOfGlyphToInsert: a String appearing as 0xEB pr 0x2014

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: nothing truely useful. Does return true if successful, false

//-- if the arguments or the selection is invalid.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ insertGlyph ('0xBC') ; // 1/4 fraction

//~ insertGlyph ('0x401') ; // Capital E with umlaut

//~ insertGlyph ('0x2020') ; // Dagger

//-------------------------------------------------------------------------

//-- Notes: Use the Info Panel with a single character selected to learn

//-- the glyph number. These are unicode numbers or in very simple cases

//-- they are ascii number. But they are Hexidicmal based. However, they

//-- may be large 4 digit numbers or smaller 2 digit numbers based upon

//-- the specific glyph.

//-------------------------------------------------------------------------

//-- Written: 2010.04.25 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Verify that what we were passed was a valid glyph number with the 0x

var len = charCodeOfGlyphToInsert.length ;

if (((len != 4) && (len != 5) && (len != 6)) || (charCodeOfGlyphToInsert.substr (0, 2) != '0x')) {

return false ;

}

//-- Verify that the selection is an insertion point, but check docs first

if (1 > app.documents.length) {

return false ;

}

var curSel = app.selection ;

if ((curSel.length != 1) || (curSel[0].constructor.name != 'InsertionPoint')) {

return false ;

}

//-- create the glyph. Not really necessary to make it a spearate variable,

//-- but this makes it easier to debug.

var glyph = String (unescape ('%u' + ('00').substr (0, 6 - len) + charCodeOfGlyphToInsert.substr (2))) ;

//-- insert the glyph

curSel[0].insertionPoints[0].contents = glyph ;

return true ;

}

Determine Publication Volume and Issue

2010-04-26T07:03:00.001-04:00

Not just for print publications

This very generic function was designed to determine the publication volume and issue numbers for newspapers publishing 7 days a week. It can be used, however to compare any two dates. Just let volume represent years and issue represent days.

Of interest in this function is the methods of validating the arguments. ECMA script, JavaScript, and ExtendScript don't do nice jobs of validating object types. Looking at a constructor is as about as good as you can get, and even that isn't totally foolproof -- though it would take more than a fool to break it.

Also in this function is one of several ways to create a duplicate date object. In this case creating a new date by parsing the original date. Setting one date to another date with just an = will cause both variables to respond to a method applied to either one.

function determineVolumeAndIssue (pubDate, refDate, refVolume) {

//-------------------------------------------------------------------------

//-- D E T E R M I N E V O L U M E A N D I S S U E

//-------------------------------------------------------------------------

//-- Generic: Yes. Should work with any ECMA based scripting language

//-- including ExtendScript and JavaScript.

//-------------------------------------------------------------------------

//-- Purpose: To return an object with the publication volume and

//-- publication issue for a passed publication date given a reference

//-- date and the volume number on that reference date. This function

//-- can also be used to count forwards or backwards in years and days

//-- between

//-------------------------------------------------------------------------

//-- Arguments:

//-- pubDate: a Date object for the publication date. Or, if you are

//-- comparing dates, this is the date you want to investigate.

//-- refDate: a Date object. This date is the date that Issue 1 for the

//-- passed volume number was published (will be published).

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: a custom object with two properties:

//-- .volume: a Number for the volume number

//-- .issue: a Number for the issue number

//-- NOTE: both values are set to -1 if any of the arguments are

//-- incorrect.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var pubDate = new Date (Date.parse('April 21, 2010')) ;

//~ var refDate = new Date (Date.parse('August 4, 2009')) ;

//~ var refVolume = 101 ;

//~ var vi = determineVolumeAndIssue (pubDate, refDate, refVolume) ;

//~ var volume = vi.volume ;

//~ var issue = vi.issue ;

//-------------------------------------------------------------------------

//-- Notes:

//-- The refDate is the date of Issue 1 for the refVolume. The

//-- function assumes a daily publication schedule.

//-- This version does not work for 1-6 days per week. That code is more

//-- complex and not posted with this version.

//-- Issues are always positive numbers. If the refDate is after the

//-- pubDate, the Volume number will be decremented, but the Issue

//-- number will still be a postive.

//-- See the note about return values

//-------------------------------------------------------------------------

//-- Written: 2010.04.21 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- create the return object with the default error values

var ro = {volume:-1, issue:-1} ;

//-- Verify that the arguments are valid, leaving them as separate if

//-- statuements to make it easier to debug.

if ((typeof pubDate != 'object') || (pubDate.constructor.name != 'Date')) {

return ro ;

}

else if ((typeof refDate != 'object') || (refDate.constructor.name != 'Date')) {

return ro ;

}

else if (isNaN (refVolume = parseInt (refVolume))) {

return ro ;

}

//-- Get a two key comparisons

var y0 = refDate.getYear () ;

var y1 = pubDate.getYear () ;

//-- Create a comparison date to determine if the current date

//-- is before or after the volume referece date.

//-- Using the Date.parse because just setting the date creates

//-- a pointer which then destroys the volumeReferenceDate.

//-- this is slightly slower, but not a deathly slow

var comparisonDate = new Date (Date.parse (refDate)) ;

//-- Move to the same year as the passed date

comparisonDate.setYear (1900 + y1) ;

var timeDifference = comparisonDate.getTime () - pubDate.getTime () ;

//-- Using the time difference determine if we are a before or after the

//-- reference date, add {using the normal ids for Issue and Volume}

//-- calcuate the volume and issue numbers and put them back into

//-- the passed object.

if (0 >= timeDifference) {

//-- we are this number of issues past the volume referece date

ro.issue = String (1 + Math.ceil (Math.abs(timeDifference) / (1000 * 60 * 60 * 24))) ;

ro.volume = String (Math.floor (y1 - y0) + refVolume) ;

}

else {

//-- back up a year.

comparisonDate.setYear (1900 + (y1 - 1)) ;

timeDifference = comparisonDate.getTime () - pubDate.getTime () ;

ro.issue = String (1 + Math.ceil (Math.abs (timeDifference) / (1000 * 60 * 60 * 24))) ;

ro.volume = String (Math.floor ((y1 -1) - y0) + refVolume) ;

}

//-- all done

return ro ;

}

Set Text Variables

2010-04-19T10:04:00.004-04:00

Part of a routine to set folios

I used to set folios by leaving misspelled tags on pages such as 'mMonth' and then scripting their replacement for folios. The advantage of this is that if a user fails to run the script that does the swap, or if the document doesn't conform to the site's naming convention, the misspelled tags remain and hopefully they would be found during a spell check of the document. Alas, users don't seem to follow the rules.

So, I've changed to using Adobe InDesign text variables for folios. The template would be set to have no values and then at key moments (like opening, and saving as) the values would get set.

The function below makes it easy to set values as it adds the text variable if it doesn't exist.

function setCustomTextVariable (docRef, name, value) {

//-------------------------------------------------------------------------

//-- S E T C U S T O M T E X T V A R I A B L E

//-------------------------------------------------------------------------

//-- Generic: Yes for InDesign CS4 and newer.

//-------------------------------------------------------------------------

//-- Purpose: To set a Custom Text Variable value. These can be used for

//-- a multitude of items, but they are commonly used for folios.

//-------------------------------------------------------------------------

//-- Arguments:

//-- docRef: The reference to the document to alter

//-- name: The name of the CustomText Variable

//-- value: The text that the CustomText Variable should be set to.

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: true unless an error occurs, which returns false.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ setCustomTextVariable (app.documents[0], 'Publication', 'Star-Ledger')

//-------------------------------------------------------------------------

//-- Notes: The Text Variable does not have to exist, this will create it.

//-- But if the text variable is not a Custom Text Variable, its value

//-- won't be able to be set, and this function will fail silently. See

//-- returns above.

//-------------------------------------------------------------------------

//-- Written: 2010.04.19 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

try {

var atv = docRef.textVariables.everyItem() ;

if (atv.hasOwnProperty (name)) {

//-- Note, not testing to see if the value can be set. If the TV

//-- isn't a 'Custom' TV, this will fail.

atv [name].variableOptions.contents = value ;

}

else {

//-- Create the TV and set the value.

var newTV = docRef.textVariables.add({name:name, variableType:VariableTypes.CUSTOM_TEXT_TYPE}) ;

newTV.variableOptions.contents = value ;

}

return true ;

}

catch (failSilently) {

var localError = failSilently ;

return false ;

}

Get Document that Triggered Event

2010-04-16T20:03:00.003-04:00

The correct document isn't always the one in front...

Event handlers are ways to run scripts when certain key events happen in Adobe InDesign or Adobe InCopy. Most things can be caught if there is a menu version of that function. Adobe's documentation does a decent job of explaining the common events, but not what to do with the 'event' itself, and is downright poor at the rest of the event handler issues.

But below is a very simple function that you can call inside the event handlers for 'open' and for 'close' event. Imagine you had multiple documents open. Now imagine that the windows are stacked so that you can see the close button for all the windows. Now assume you have an event handler that will do something useful (like look for overset text, preflight, adjust folios, for log a version comment). Well your event handler needs to know which document you just tried to close. That is where this function comes into play.

Event handlers always reference a function. But the function is a specified only in name. You can't pass it anything. Well your event handler will always receive a single argument -- an event. And the event has a property called .target and that .target property has another property .name. And the name of the target of the event is the name of the document.

function docRefFromEvent (event) {

//-------------------------------------------------------------------------

//-- D O C R E F F R O M E V E N T

//-------------------------------------------------------------------------

//-- Generic: Yes for ExtendScript CS3, CS4, etc.

//-------------------------------------------------------------------------

//-- Purpose: To return the document triggering the event handler or the

//-- default of the frontmost document.

//-------------------------------------------------------------------------

//-- Arguments: event: the event which triggered some other function which

//-- in turn called this function. Likely it would be an open or a close

//-- function so that you can catch the correct document. For example,

//-- you need this for open handlers becasue if you have two documents

//-- open, documents[0] or .activeDocument will point to the first doc

//-- and not the document you just opened. Likewise with closing files,

//-- your windows could be tiled and you can close a file other than the

//-- active or the documents[0].

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: Either a reference to the front document or the document that

//-- triggered the passed event.

//-------------------------------------------------------------------------

//-- Written: 2010.04.06 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Created for version 3.52

if ((event != undefined) && event.hasOwnProperty ('target') && event.target.hasOwnProperty ('name')) {

var testDocRef = app.documents.itemByName (event.target.name) ;

if (testDocRef != null) {

return testDocRef ;

}

return app.documents[0] ;

}

Compare Two Objects for Matching Properties

2010-02-12T11:49:00.007-05:00

hasMatchingProperty

I've been way too busy with a large project recently to post anything here, but I created this nice function to compare properties of two objects. It would be great as an extension to the Object class if you felt so inclined.

Note, with the way the properties are compared using three equal signs === there is no need to do a separate verification that the property of each object is of the same variable type. The === is only true if the variable type is the same without any coercion.

If you wanted to check every property of the two objects then you would need a little more code to iterate through the properties of one object with the properties of another object. I set that up, but alas didn't write it as a generic function to share.

function hasMatchingProperty ( o1 , o2 , pn ) {

//-------------------------------------------------------------------------

//-- H A S M A T C H I N G P R O P E R T Y

//-------------------------------------------------------------------------

//-- Generic: Yes! should work for any ECMA 2.62 based language including

//-- JavaScript and ExtendScript

//-------------------------------------------------------------------------

//-- Purpose: To determing if two objects possess the same property and the

//-- value of that property is an exact match with now cooresion. If

//-- neither has that property then the result is also true -- the value

//-- matches for each object

//-------------------------------------------------------------------------

//-- Arguments:

//-- o1: The first object

//-- o2: The second object

//-- pn: The string name of the property

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: a Boolean true if the objects have matching properties, else

//-- false

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var a = hasMatchingProperty ( {A:"z", C:0, E:false} , {B:"Y", C:0, E:0} , 'A' ) ;//=false

//~ var b = hasMatchingProperty ( {A:"z", C:0, E:false} , {B:"Y", C:0, E:0} , 'B' ) ;//=false

//~ var c = hasMatchingProperty ( {A:"z", C:0, E:false} , {B:"Y", C:0, E:0} , 'C' ) ;//=true

//~ var d = hasMatchingProperty ( {A:"z", C:0, E:false} , {B:"Y", C:0, E:0} , 'D' ) ;//=true

//~ var e = hasMatchingProperty ( {A:"z", C:0, E:false} , {B:"Y", C:0, E:0} , 'E' ) ;//=false

//-------------------------------------------------------------------------

//-- Notes: for a match with cooresion change the === to ==

//-------------------------------------------------------------------------

//-- Written: 2010.01.27 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Check to see if both Have the Property And Both of the Property

//-- Values Exactly Match without coorersion

if ( ( o1.hasOwnProperty( pn ) == o2.hasOwnProperty ( pn ) ) && ( o1[ pn ] === o2[ pn ] ) ) {

return true ;

}

//-- Check to see if both are missing the property

if ( ( ! o1.hasOwnProperty( pn ) ) && ( ! o2.hasOwnProperty( pn ) ) ) {

return true ;

}

//-- No matching

return false ;

}

Gather Assigned Frames

2009-11-13T10:38:00.000-05:00

The Text Frames associated with Adobe InCopy Assignments

On to more things with Adobe InCopy Assignments in Adobe InDesign.

The generic function below will generate a return object with two properties. One contains references to every text frame in the passed document reference that has assigned content. The second segregates the assigned frames by assignment.

Either property will allow you to locate the frames that are used in an assignment.

function gatherAssignedFrames ( docRef ) {

//-------------------------------------------------------------------------

//-- G A T H E R A S S I G N E D F R A M E S

//-------------------------------------------------------------------------

//-- Generic: Yes.

//-------------------------------------------------------------------------

//-- Purpose: To return an associative array of all the text frames in the

//-- passed coument that have associated Adobe InCopy Assignments

//-------------------------------------------------------------------------

//-- Arguments:

//-- docRef: An [object Document] to investigate

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: a custom object with two properties

//-- .assignmentFrames: An Associatve Array of Assignment IDs using

//-- the $ prefix as described below.

//-- Each element will contain a property for every text frame

//-- with the text frame ID with the $ prefix.

//-- The contents of these properties will be a reference

//-- to the text frame itself.

//-- .assignedTextFrames: An Associative Array of Text Frame IDs

//-- with each Text Frame ID have a $ prefix. The contents

//-- of each property is a reference to the text frame itself.

//-------------------------------------------------------------------------

//-- $ Prefix on IDs

//-- IDs are prefixed with a $. Thus Text Frame 188 will be returned as

//-- $188. This is done because objects cannot be named with numbers.

//-------------------------------------------------------------------------

//-- Sample Use:

//-- gatherAssignedFrames ( docRef )

//-------------------------------------------------------------------------

//-- Notes: Decide how you want to handled the Unassigned InCopy Content

//-- There will be references to that assignment as well. It is valid.

//-------------------------------------------------------------------------

//-- Written: 2009.11.12 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Note, we are using a $ prefix on the object names in the associative

//-- array because pure numbers are not allowed.

//-- Create the return object.

var returnObject = new Object () ;

returnObject.assignmentFrames = new Object () ;

returnObject.assignedTextFrames = new Object () ;

//-- Gather all assignments.

var allAssignments = app.documents[0].assignments ;

//-- Loop through each of the assignments -- backwards for efficiency.

for ( var ai = allAssignments.length - 1 ; ai >= 0 ; ai-- ) {

//-- Get a reference to the current assignment in the loop and its ID.

var activeAssignment = allAssignments[ai] ;

var activeAssignmentID = '$' + activeAssignment.id ;

//-- Add the property to the return object for the current assignment.

returnObject.assignmentFrames[ activeAssignmentID ] = new Object () ;

//-- Get a reference to every assigned story for the assignment.

//-- There can be one or many. Most CMS's use many.

var allAssignedStories = activeAssignment.assignedStories ;

//-- Loop backwards through each story of the active assignment.

for ( var asi = allAssignedStories.length - 1 ; asi >= 0 ; asi-- ) {

//-- Get a reference to the story indicated by the loop index.

var activeStory = allAssignedStories[asi].storyReference ;

//-- Get all the text containers for the active story.

//-- There could be more than one if the text frame is

//-- manually threaded to additonal frames.

var allTextContainers = activeStory.textContainers ;

//-- Finally...

//-- Loop through all the text containers (text frames in most

//-- cases) and add the container ID with a $ prefix to both

//-- main properties of the return object.

for ( var tci = allTextContainers.length - 1 ; tci >= 0 ; tci-- ) {

//-- Get a reference to the container indicated by the loop.

var activeTextContainer = allTextContainers[tci] ;

var activeTextContainerID = '$' + activeTextContainer.id ;

//-- Add the IDs to the two objects

returnObject.assignedTextFrames[ activeTextContainerID ] = activeTextContainer ;

returnObject.assignmentFrames[ activeAssignmentID ][ activeTextContainerID ] = activeTextContainer ;

}

return returnObject ;

}

Delete Empty Assignments

2009-11-12T11:58:00.004-05:00

Part of a Document Cleanup Routine

I've been working with Adobe InCopy Assignments again.

When users delete frames that used to have assigned stories, the assignment remains with the Adobe InDesign document. If the assignment manages to get updated (it can happen easily) then the assignment file will contain no Adobe InCopy stories. What will happen if the user opens the Adobe InCopy story is they will get an ugly message when opening the story and they will see the page where the assigned stories used to be, but they can't edit it.

To put things back, the story needs to get reassigned and re-saved.

But if the original Adobe InDesign document still has the assignment is saved _last_ then the user sees the original page.

This function does nothing other than delete the empty assignments. To fix all ills, you could also delete the assignment file from the file server -- but the better solution is to save the page where the assignment currently exists.

function deleteEmptyAssignments ( docRef ) {

//-------------------------------------------------------------------------

//-- D E L E T E E M P T Y A S S I G N M E N T S

//-------------------------------------------------------------------------

//-- Generic: Yes

//-------------------------------------------------------------------------

//-- Purpose: To delete all assignments with no assignedStories

//-------------------------------------------------------------------------

//-- Arguments: docRef: a reference to the document to be processed

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: Boolean true if successful. Boolean false if an error occured

//-------------------------------------------------------------------------

//-- Sample Use: deleteEmptyAssignments ( app.documents[0] )

//-------------------------------------------------------------------------

//-- Notes: Part of a larger function.

//-------------------------------------------------------------------------

//-- Written: 2009.11.12 by Jon S. Winters of electronic publishing support

//-- at the Hilton Universal City, Los Angeles, CA

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

try {

//-- Loop through every assignment.

var allAssignments = docRef.assignments ;

for ( var aai = allAssignments.length - 1 ; aai >= 0 ; aai-- ) {

//-- if the assignment isn't the special 'Unassigned' assignmetn and if

//-- the assignment has no assigned stories, then remove it.

if ( ( allAssignments[aai].assignedStories.length == 0 ) && ( allAssignments[aai].name != 'Unassigned InCopy Content' ) ) {

allAssignments[aai].remove() ;

}

return true ;

}

catch ( failSilently ) {

var errorObject = failSilently ;

return false ;

}

Remove Column of Text from Adobe InDesign or Adobe InCopy Story

2009-11-03T10:16:00.001-05:00

Parent function from a prior post

A prior post listed the removeColumn function which can remove a delimited column from a string. This is the wrapper that calls that function to remove a column of text from a specified set of paragraphs within an Adobe InDesign or Adobe InCopy story.

If you want it to work on a set of selected paragraphs then pass it:

app.selection[0].paragraphs

which will provide the paragraphs of the selection even if the user does an imperfect (read faster ) selection. The sample as shown would do the entire story.

As an alternative, check out the paragraphs collection method which is oddly named

.itemByRange(start,stop)

as that allows you to point to a specific range of paragraphs.

As with with the removeColumn function, this is great for cleaning up sports agate text where you need to remove columns from a set of paragraphs.

function removeColumnFromParagraphs ( pgraphs , colToKill , delimiter ) {

//-------------------------------------------------------------------------

//-- R E M O V E C O L U M N F R O M P A R A G R A P H S

//-------------------------------------------------------------------------

//-- Generic: Yes for Adobe InDesign or Adobe InCopy CS3 or newer

//-------------------------------------------------------------------------

//-- Purpose: To remove a column from some tab delimited text in a

//-- collection of paragraphs.

//-------------------------------------------------------------------------

//-- Arguments: 3

//-- pgraphs: an Adobe InDesign or Adobe InCopy collection of

//-- paragraphs. This is can be generated by something like this:

//-- var pgraphs = story[0].paragraphs ;

//-- colToKill: An integer of zero based column of text to remove.

//-- in tab delimited columns

//-- delimiter: OPTIONAL. If not specified a tab will be used.

//-------------------------------------------------------------------------

//-- Calls: the removeColumn function -- see prior post

//-------------------------------------------------------------------------

//-- Returns: nothing, but alters the text of tha passed text.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ removeColumnFromParagraphs ( app.selection[0].parentStory.paragraphs , 3 )

//~ removeColumnFromParagraphs ( app.selection[0].parentStory.paragraphs , 0 )

//~ removeColumnFromParagraphs ( app.selection[0].parentStory.paragraphs , -1 )

//-------------------------------------------------------------------------

//-- Notes: Can alter formatting of the paragraphs if they are not

//-- consistently formatted. Uses regular expressions and some array

//-- methods which are not format friendly

//-------------------------------------------------------------------------

//-- Edited: 2009.11.01 by Jon S. Winters of electronic publishing support

//-- in the business center at CLT while waiting on a flight.

//-- The basis for the posted function was taken from a long running

//-- section of code.

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- check the third parameter and if not passed

if ( delimiter == undefined ) {

delimiter = '\t' ; // or ' '

}

//-- Get a count of the number of pargraphs in the collection

var numPgraphs = pgraphs.length ;

//-- Loop through every paragraph

for ( var pIndex = numPgraphs-1 ; pIndex >= 0 ; pIndex-- ) {

var textWithColumnRemoved = removeColumn ( pgraphs[pIndex].contents , colToKill , delimiter ) ;

//-- See the original had a return and if the final didn't.

//-- Note the order is important to maximize the speed

if ( ( ! new RegExp ( '\r' ).test ( textWithColumnRemoved ) ) && ( new RegExp ( '\r' ).test ( pgraphs[pIndex].contents ) ) ) {

//-- Add the return back in as the paragraph contents is replaced

pgraphs[pIndex].contents = textWithColumnRemoved + '\r' ;

}

else {

//-- Just set contents to the text without the column

pgraphs[pIndex].contents = textWithColumnRemoved ;

}

//-- continue with loop

}

Remove Column of Text

2009-11-02T10:48:00.002-05:00

Great for Sports Agate

The following function is something I regularly use for removing a column of text in sports agate cleanup scripts. It is very generic. Pass it a string, a zero based column index, and the delimiter (usually a tab specified as '\t' ) and the function will remove that column.

Note, you would need to call this with something that can process all the paragraphs. As this will only handle one paragraph at a time unless you get real fancy with the calls.

Look for another function to call this one in an upcoming post.

function removeColumn ( orig, col, delimiter ) {

//-------------------------------------------------------------------------

//-- R E M O V E C O L U M N

//-------------------------------------------------------------------------

//-- Generic: Yes. Should work for any ECMAScript based languages such as

//-- ExtendScript and JavaScript.

//-------------------------------------------------------------------------

//-- Purpose: To remove a 'delimiter' separated 'col'umn of text from the

//-- 'orig'inal passed string.

//-------------------------------------------------------------------------

//-- Arguments: 3

//-- orig: A string which delimited columns

//-- col: A column number. This can be negative to work from the back

//-- delimiter: a string which is used to delimit columns

//-------------------------------------------------------------------------

//-- Calls: Nothing, but requires the .split(), .splice(), and .join()

//-------------------------------------------------------------------------

//-- Returns: The original string with the specified column removed.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ removeColumn ( "a\tb\tc\td\t\e\tf", -1, '\t' ) ; // "a\tb\tc\td\t\e"

//~ removeColumn ( "a\tb\tc\td\t\e\tf", 2, '\t' ) ; // "a\tb\td\t\e\tf"

//-------------------------------------------------------------------------

//-- Notes: Works great with negative column indexes. -1 is the last column

//-- If removing the last column be careful if you need the text to

//-- retain the final return or line break as this will delete it.

//-------------------------------------------------------------------------

//-- Edited: 2009.11.01 by Jon S. Winters of electronic publishing support

//-- Originally an internal function of a larger function.

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- break the string into an array using the passed delimiter

var sa = orig.split(delimiter) ;

//-- Call inbuilt splice method to remove the specified element of the array

sa.splice(col,1) ;

//-- Join the array into a string using the passed delimater.

return sa.join(delimiter) ;

} //-- end of internal function.

Delete Unused Master Pages

2009-10-23T10:54:00.001-04:00

Master Pages in Adobe InDesign are a great way to automate the production of pages. But Master Pages, also called Master Spreads, can have a serious impact of production in a negative way too. Every Master Page added to a template or document increases the file size. And sometimes, if the Master Pages aren't built in a efficient and productive manner, the increase in size can be substantial.

And late in the production cycle, that extra file size slows down every save, every print, every export, every open, everything.

The partial solution is to delete the unused Master Pages. And this function does that.

function xUnusedMasters( docRef ) {

//-------------------------------------------------------------------------

//-- X U N U S E D M A S T E R S

//-------------------------------------------------------------------------

//-- Generic: Yes for Adobe InDesign.

//-------------------------------------------------------------------------

//-- Purpose: To delete all the master pages that are not applied to a

//-- a document page or a Master Page that is applied to a document.

//-------------------------------------------------------------------------

//-- Arguments: docRef: the document to examine.

//-------------------------------------------------------------------------

//-- Calls: addMasterName() an internal recursive function to generate

//-- an associative array of master page names that are in use.

//-------------------------------------------------------------------------

//-- Returns: nohting.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ xUnusedMasters( app.documents[0] ) ;

//-- OR:

//~ xUnusedMasters( returnDocumentReference ( pageOfWindow () ) ) ;

//-------------------------------------------------------------------------

//-- Notes: Preserves the entire hierachy of all the master pages that

//-- are based on other master pages.

//-------------------------------------------------------------------------

//-- Written: 2009.10.22 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Create an object to record the names of the master pages to keep.

var mpNames = new Object () ;

//-- get a reference to all the pages of the passed document.

var allPages = docRef.pages ;

//-- loop through each page and add to the list of

for ( var pIndex = allPages.length - 1 ; pIndex >= 0 ; pIndex-- ) {

//-- Add the name of the master page applied to this page

//-- to the list of master pages to keep. Using and

//-- Associative Array allows the list to only contain

//-- a single instance if a single master page is used

//-- more than once in the document.

mpNames = addMasterName ( mpNames , allPages[pIndex] ) ;

}

//-- At this point the mpNames object has a property for the

//-- name of every master page that needs to be kept.

//-- Get a reference to all the master pages.

//-- NOTE: the '[None]' master page will not show up in this.

var allMasterPages = docRef.masterSpreads ;

//-- Loop through all the master pages.

for ( var mpIndex = allMasterPages.length - 1 ; mpIndex >= 0 ; mpIndex-- ) {

//-- compare this against the database of master pages to keep

if ( ! mpNames[allMasterPages[mpIndex].name] ) {

//-- If the associative array dosn't have that master page name

//-- then delete the master page.

allMasterPages[mpIndex].remove() ;

}

return ; //-- nothing, just return

//-- Below is an internal function to keep the main function generic

function addMasterName ( MPDB , pageRef ) {

//---------------------------------------------------------------------

//-- A D D M A S T E R N A M E

//---------------------------------------------------------------------

//-- Generic: Yes for Adobe InDesign

//---------------------------------------------------------------------

//-- Purpose: A recursive function that adds the name of the master

//-- page applied to the passed pageRef to the passed

//-- associative array MPDB

//---------------------------------------------------------------------

//-- Arguements: 2

//-- MPDB: An Associative Array with a value for each Master Page

//-- used.

//-- pageRef: The page or master page to get and add the master

//-- page name

//---------------------------------------------------------------------

//-- Calls: itself. This is a recursive function.

//---------------------------------------------------------------------

//-- Returns: The associative array MPDB with any new master page

//-- names from the passed pageRef

//---------------------------------------------------------------------

//-- Written entirely from scratch to replace a flawed version.

//-- Written 2009.10.22 by Jon S. Winters

//-- eps@electronicpublishingsupport.com

//---------------------------------------------------------------------

//-- Because the function is recursive, check to see if it was sent

//-- a reference to a non-existent master page. If so, return

//-- to the caller the same object it was sent.

if ( pageRef == null ) { return MPDB ; }

//-- Check to see if the passed pageRef is a page.

//-- If it is a page don't add page name.

//-- But if pageRef is master page then add its name.

if ( pageRef.constructor.name == 'MasterSpread' ) {

MPDB[pageRef.name] = true ;

}

//-- Call the function recursively, but send the appliedMaster

//-- of the passed pageRef and return the value.

return addMasterName ( MPDB , pageRef.appliedMaster ) ;

}//-- end of internal function

}//-- end of xUnusedMasters

Get Page of Window

2009-10-22T10:21:00.000-04:00

What is the user looking at?

I've found this function very handy lately. If you are opening files without showing the window ( as strange as that might seem, it can be very useful ), you will need a reference to what the user is viewing. This function returns the page the the Adobe InDesign thinks the user is looking at.

From that page reference you can easily get the document reference (remember it might not be app.activeDocument or app.documents[0]. See some prior posts to know why, but opening documents without showing the window is a really good reason!

Now, for some ideas. If you know the page that the user is looking at, you have ways to control printing of just that page, exporting just that page, adding items to just that page, applying master pages to just that page, etc...

function pageOfWindow () {

//-------------------------------------------------------------------------

//-- P A G E O F W I N D O W

//-------------------------------------------------------------------------

//-- Generic: Yes for Adobe InDesign, but not InCopy

//-------------------------------------------------------------------------

//-- Purpose: To return a reference to a the page that Adobe InDesign

//-- considers the active page.

//-------------------------------------------------------------------------

//-- Arguments: None

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: A page reference to the page that Adobe InDesign considers

//-- the active page. If no pages can be found it returns null ;

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var currentPage = pageOfWindow() ;

//-------------------------------------------------------------------------

//-- Notes: The page returned can be a Master Page

//-------------------------------------------------------------------------

//-- Written: 2009.09.22 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- 2009.09.24 added error handling

try {

//-- close any StoryWindows

while ( new RegExp ('Story','i').test( app.activeWindow.reflect.name ) ) {

app.activeWindow.close() ;

}

} catch (err) {

var errorObject = err ;

return null ;

}

//-- Get the page reference for the window displayed in the

//-- active Layout Window

return app.activeWindow.activePage ;

}

Build Menu Item

2009-10-20T12:16:00.002-04:00

This is both some simple and some complex code to construct a menu item in a menu.

One advantage of what this does is that it creates a stand alone script in the Scripts Panel folder that can be used to Assign a Keyboard Shortcut to a custom menu item -- something normally not possible.

function buildMenuItem (aMenu, menuItemName, eventFunction , checkItem , addShortcutScript , forceUpdateShortcut ) {

//-------------------------------------------------------------------------

//-- B U I L D M E N U I T E M

//-------------------------------------------------------------------------

//-- Generic: Yes, but calls an external function for creating the

//-- shortcut scripts.

//-------------------------------------------------------------------------

//-- Purpose: To add items and event listners to a passed menu in the

//-- menu bar.

//-------------------------------------------------------------------------

//-- Parameters: 6

//-- aMenu: A menu object created with the 'makeMainMenu' function.

//-- menuItemName: A string for the text as it should appear in the

//-- menu.

//-- eventFunction: This is the name of the function that should be

//-- invoked when the menu item is accessed

//-- checkItem: OPTIONAL. A boolean to indicate that the item should

//-- be checked. The default is false.

//-- addShortcutScript: OPTIONAL. a boolean to indicate that an

//-- auxilary script should be added which could be used as

//-- the recipitant of a keyboard shortcut. The default is false.

//-- forceUpdateShortcut: OPTIONAL, a boolean that when true will

//-- rewrite the shortcut script regarless of if it already exists

//-- we don't want to do this all the time because of the speed

//-- and the chance that it would trigger the keyboard shortcut

//-- to get lost.

//-------------------------------------------------------------------------

//-- Calls:

//-- findScriptsPanelFolder()

//-- buildMenuFolderStructure()

//-------------------------------------------------------------------------

//-- Returns: Nothing.

//-------------------------------------------------------------------------

//-- Written by Jon S. Winters.

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Edited: 2009.01.23 to add the option to check the menu item.

//-- Edited: 2009.10.06 to start the process of making stand alone scripts

//-- that can be used for shortcuts for each menu item added.

//-- Verify that the checked item has been sent, else assume false

if ( checkItem == undefined ) {

checkItem = false ;

}

//-- Build the pat menu by constructing the action and then the menu item

var mMenuItem = aMenu.menuItems.item( menuItemName ) ;

if ( mMenuItem == null ) {

var mAction = app.scriptMenuActions.add( menuItemName ) ;

//-- Version 2r, add check

mAction.checked = checkItem ;

//alert ("Making menu: " + menuItemName + " has Action ID: " + mAction.id ) ;

var mListener = mAction.eventListeners.add( "onInvoke", eventFunction , false ) ;

var mMenuItem = aMenu.menuItems.add( mAction , LocationOptions.AT_END ) ;

//-- 2009.10.06 start the process of adding keyboard shortcut scripts.

//-- 2009.10.11 Some sub menus use '-' to create separators

//-- 2009.10.11 Also skip when the name doesn't exist

if ( addShortcutScript && ( menuItemName != '-' ) && ( menuItemName != '' ) ) {

try {

//-- Call an external function to determine the location of the

//-- application's Scripts Panel Folder. Then get the name

//-- of the parent menu of the menu item being created.

var shortcutDestination = Folder ( findScriptsPanelFolder() + '/' + buildMenuFolderStructure ( aMenu ) ) ;

//-- Verify that the folder exists because ExtendScript will

//-- lie about the file if the folder isn't there.

if ( shortcutDestination.verify ( ) ) {

//-- Add to that the name of the menu and create a file

//-- Object.

//-- Version 2.67 remove any / in name

var f = File ( shortcutDestination + '/' + menuItemName.replace(new RegExp ( "/","gm"),encodeURIComponent ('⁄')) + '.jsx' ) ;

//-- Test that file object. If it already exists and the function

//-- wasn't asked to overwrite it, skip the process.

if ( ( ! f.exists ) || forceUpdateShortcut ) {

//-- Create a string which will be written to a file with a

//-- .jsx file extension. The string will include a

//-- preprocessor directive to match the running target

//-- engine. No need to match the host applicaiton.

//-- Create a fake event object that can be passed for when

//-- the menu item is created in an loop of an array.

//-- To the reciving function it will look like:

//-- event.target.name

//-- Write a commented header

var fileContents = '//-- Created: ' + new Date () + ' by the ' + arguments.callee.name +' function.\r' ;

//-- if there is a target engine active, include this.

if ( $.engineName != undefined ) {

fileContents += '#targetengine ' + $.engineName + '\r'

}

//-- Now call the passed function and supply it with an object

//-- literal of the menu name to be used when the function

//-- is called from within a loop of an array.

//-- Version 2.67 escape any quotes in the menu item name.

fileContents += eventFunction.name + "({target:{name:\'" + menuItemName.replace (new RegExp ( "([\'\"“”‘’])",'gm'), "\\$1" ) + "\'}})" ;

//-- write the actual file.

f.open ('w') ;

f.write (fileContents) ;

f.close ();

}

catch ( err ) {

var errorObject = err ;

try {

f.close() ;

}

catch ( err ) {

var errorObject = err ;

}

Add a Main Menu

2009-10-20T12:03:00.004-04:00

Below is code to add a main menu at the right side of InDesign's or InCopy's menu bar:

function makeMainMenu(menuName) {

//-------------------------------------------------------------------------

//-- M A K E M A I N M E N U

//-------------------------------------------------------------------------

//-- Generic: Yes.

//-------------------------------------------------------------------------

//-- Purpose: To add the main menu in the menu bar.

//-------------------------------------------------------------------------

//-- Parameters: menuName: A string for the name of the main menu.

//-------------------------------------------------------------------------

//-- Returns: A menu object.

//-------------------------------------------------------------------------

//-- Written by Jon S. Winters.

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

try {

//-- OPTIONAL: You may want to try to remove the menu if you are

//-- going to change it radically.

removeMenu(menuName) ;

var aMenu = app.menus.item("$ID/Main").submenus.item(menuName);

aMenu.title ; //-- this errors if the menu doesn't exist, That causes

//-- the menu to be added in the catch statement.

//-- Internal function

function removeMenu (killThisMenu) {

var mySampleScriptMenu = app.menus.item("$ID/Main").submenus.item(killThisMenu);

mySampleScriptMenu.remove();

}

catch ( err ) {

var aMenu = app.menus.item("$ID/Main").submenus.add(menuName);

}

return aMenu ;

}

Pad Text

2009-10-19T23:10:00.000-04:00

The XML encoding and decoding functions posted yesterday call a function pad() which is below.

Padding is the process of adding extra text to ( typically ) the front of a string of numbers to make the string a certain length.

This is a generic function to pad any thing that can be converted to a string to a specified count of digits.

It is unique in that it allows anything to be used as a pad character, though zero padding is the default.

Called by the of epsEntitify() function. That posting can be found here.

function pad ( orig , count , padWith ) {

//-------------------------------------------------------------------------

//-- P A D

//-------------------------------------------------------------------------

//-- Generic: Yes!

//-------------------------------------------------------------------------

//-- Purpose: to pad the 'orig' number or string to a fixed 'count'

//-- characters or digits using the 'padWith' character

//-------------------------------------------------------------------------

//-- Returns a string (even if it doesn't need to be padded)

//-------------------------------------------------------------------------

//-- Sample Calls:

//-- p = pad (7,3,0) ; // '007'

//-- p = pad (21,1) ; // '21'

//-- p = pad ('Right',10,' ') ; // ' Right'

//-- p = pad ('Left',0,' ' ) ; // 'Left'

//-------------------------------------------------------------------------

//-- Written 2009.05.01 at the PDX airport by Jon S. Winters

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Check arguments

//--default of zero as string

var padChar = "0" ;

//-- but if they sent something, use the first character of it

if ( padWith != undefined ) { padChar = String (padWith).substr (0,1) ; }

//-- Convert to a string (actually adding the "" to it would have worked.)

var withThis = String ( orig ) + '' ;

//-- Check its length, with it is long enought return. Until then keep

//-- adding the padChar

while ( count > withThis.length) {

withThis = padChar + withThis;

}

//-- Back to the caller

return withThis;

}

Picky XML Interpreter and a Solution for Encoding Custom Node Names

2009-10-13T10:05:00.000-04:00

Writing and Reading XML:

I have been working lots with Adobe's XML object within ExtendScript. There are some nice tools, but the biggest problem I've been having is dealing with its ability to create XML using custom nodes.

For example, I needed to write some Object Style names, not as data, but as the name of the node. This is because I needed to write some data that applied to the Object Styles. So I wanted XML node name to match the name of the Object Style.

That is fine if the name of the object style is something simple like 'Headline', but add a space as in 'Headline Frame' and suddenly there are problems. You can write the XML file because that is just text, and you can read the text file, but as soon as you ask ExtendScript to make a new XML object it will complain about the 'token'. And that makes sense because an XML node can't have a space. Nor can an XML node have < > & or %. Fine. So I wrote a function to encode those things. See entityReference.

It works to write and reread the file. And you can verify that the file is encoded, but when reading the file those items get automatically converted back into the normal strings and Adobe's XML parser still balks about the character.

Plan E: It at least works

After several other attempts, I finally settled on the encoding used in the two functions below. They leave the special characters (all but the alpha numerics) encoded with a

U_ and a 4 digit hexadecimal unicode glyph number. For example an — ( em-dash ) is:

U_2014

I would have liked to have used the more traditional:

0x followed by the unicode number as:

0x2014

but that places a number ( zero ) in the file. If the character needing to be encoded is the first character then the XML node would begin with 0 and once again, Adobe's Extendscript XML parser balks. So I settled on the U_ even though it was nonstandard.

Built-In Encoding Options

ExtendScript contains 3 pairs of encoding / decoding functions, but all three will trigger a complaint from the XML parser.

escape (aString) <--> unescape (stringExpression)

encodeURI (text) <--> decodeURI (uri)

encodeURIComponent (text) <--> decodeURIComponent (uri)

Using the epsEntitify functions:

If need to write non-standard node names to an XML file, just run the first function on the node names before creating them and writing the file. Here is the result of one node that includes two spaces:

Quote

Quote 1 Quote

It is at least marginally readable if you want to read the XML file itself.

Then when you read the XML, use the 2nd function to decode the node names. It works. The decoding is such that it very quickly returns if there is nothing to decode.

function epsEntitify ( str ) {

//-------------------------------------------------------------------------

//-- E P S E N T I T I F Y

//-------------------------------------------------------------------------

//-- Generic: Yes for ExtendScript.

//-------------------------------------------------------------------------

//-- Purpose: To replace the XML Reserved Characters in a passed string

//-- with custom values based upon hexidecimal versions of their

//-- unicode values and with a unicode U_ prefix.

//-------------------------------------------------------------------------

//-- Arguments: A string to clean up.

//-------------------------------------------------------------------------

//-- Calls: pad() to pad the hexideciaml value to 4 digits.

//-------------------------------------------------------------------------

//-- Returns: a string with all non word characters replaced with their

//-- hexidecimal value in a unicode format such as 'U_0020' for a space.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var unfitForXML = '<> close % percent'

//~ var safeForXML = epsEntitify ( unfitForXML ) ;

//-------------------------------------------------------------------------

//-- Notes: Using the .toString() method to convert to a hexideciaml value

//-------------------------------------------------------------------------

//-- Written: 2009.10.12 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Create a regular expression pattern for acceptable characters

var AlphaNumeric = new RegExp ('\\w');

//-- Create a return array ( it will be converted to a string at the end )

var eString = new Array (str.length) ;

//-- Loop through every character.

for ( var si = str.length - 1 ; si >= 0 ; si-- ) {

//-- Get a reference to the indexed character

var activeCharacter = str.charAt ( si ) ;

//-- If that character is included in the regular expression

//-- pattern then add it to the return array

if ( AlphaNumeric.test(activeCharacter) ) {

eString[si] = activeCharacter ;

}

else {

//-- It isn't an allowed character, convert it to a hexidecimal

//-- value. This uses a special feature of the built-in

//-- .toString() method to convert the value to hexideciaml

eString[si] = 'U_' + pad ( str.charCodeAt ( si ).toString(16) , 4 , '0' ) ;

}

//-- Convert the array to a string and send it back.

return eString.join ('')

}

function epsUnEntitify ( str ) {

//-------------------------------------------------------------------------

//-- E P S U N E N T I T I F Y

//-------------------------------------------------------------------------

//-- Generic: Yes, but has a very specific purpose.

//-------------------------------------------------------------------------

//-- Purpose: To take a string that has been processed with the

//-- epsEntitify() function and return it to its original values.

//-- The pair was written to encode XML files in ExtendScript

//-------------------------------------------------------------------------

//-- Arguments: str: the string to decode

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: The string decoded.

//-------------------------------------------------------------------------

//-- Written: 2009.10.13 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Create the custom pattern to find the special strings used by the

//-- epsEntitfy function. Note the parenthesis which are used for

//-- a backreferenece in the .exec() method later.

var p = new RegExp ( 'U_([0-9a-f][0-9a-f][0-9a-f][0-9a-f])' , 'gm' ) ;

//-- Loop through every match of that pattern

//-- Using the .text() method which returns true only if the

//-- passed string has a match.

while ( p.test ( str ) ) {

//-- Reset the pointer for the because the strings get

//-- shorter each time

p.lastIndex = 0 ;

//-- Use the .exec() method to determine the orignal string

//-- and the back reference.

//-- The result will have at least 2 values. [0] is the

//-- original string, and [1] is the backreference

var r = p.exec ( str ) ;

//-- convert the backreference into a base 10 number and

//-- then create a string using that character number.

var origChar = String.fromCharCode ( parseInt ( r [1] , 16) ) ;

//-- Use a basic search / replace to replace the base string

//-- with the original character.

//-- By using a regular expression and the 'gm' this

//-- can replace multiple matches at the same time.

str = str.replace ( new RegExp ( r [0] , 'gm' ) , origChar ) ;

}

return str ;

}

Traverse a Menu Item to Build a Folder Structure

2009-10-13T09:23:00.001-04:00

I've been way to much lately with user interfaces. One problem with ExtendScript and building custom menu items is that you can't make keyboard shortcuts stick. The menus tend to get built each time the script launches. And each time they get built the menu items get unique ids within the Adobe application. The problem with this is that the keyboard shortcuts are tied not to a name, but to the unique id. Thus, keyboard shortcuts won't last longer than a single launch. If you are development mode, they won't even last that long.

The solution it seems is to create a stand alone script which calls the same function as the menu. These stand alone scripts would be visible to the user in the Scripts panel of Adobe InDesign or Adobe InCopy. Since these scripts are static ( as opposed to the ever changing unique ids of menu items ) their keyboard shortcuts stick.

The function below is a function called by the function that I use to build menu items. And it can look at a menu item and determine the its name and the name of all the submenus and menus above it and create what amounts to be a folder structure to place the script into.

Well that requires a few other functions...

function buildMenuFolderStructure ( aMenu ) {

//-------------------------------------------------------------------------

//-- B U I L D M E N U F O L D E R S T R U C T U R E

//-------------------------------------------------------------------------

//-- Generic: Yes, for ExtendScript

//-------------------------------------------------------------------------

//-- Purpose: To traverse a passed menu item to determine its relationship

//-- to parent menus and build a string of menus from it that can be

//-- be used for a folder path. For example if passed a menu item as

//-- a submenu of a menu added to the menu bar with this type of

//-- structure: Utilities --> Apply Page Grid --> 7 column grid

//-- this function would return:

//-- Utilities/Apply Page Grid/7 column grid/

//-------------------------------------------------------------------------

//-- Arguments: aMenu -- a reference to a menu

//-------------------------------------------------------------------------

//-- Calls: itself.

//-------------------------------------------------------------------------

//-- Returns: a string described above

//-------------------------------------------------------------------------

//-- Sample Use: var r = buildMenuFolderStructure ( aMenu ) ;

//-------------------------------------------------------------------------

//-- Notes: very little error checking. The top menu is named 'Main'

//-------------------------------------------------------------------------

//-- Written: 2009.10.06 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

if ( aMenu.parent.name == 'Main' ) {

return aMenu.name + '/' ;

}

//-- implied else

return buildMenuFolderStructure ( aMenu.parent ) + aMenu.name + '/' ;

}

Place Tagged Text File

2009-10-12T09:19:00.000-04:00

While some think of copying and pasting text, I prefer to write formatted text to an Adobe InDesign Tagged Text file and then read the file back at the desired location. I won't go into the reasonings behind this, but despite what you might think, it is very fast to do.

Below is a generic function to place a tagged text file at a location (such as a selection).

function placeTaggedText ( location , fileRef ) {

//-------------------------------------------------------------------------

//-- P L A C E T A G G E D T E X T

//-------------------------------------------------------------------------

//-- Generic: Yes. For both InCopy and Adobe InDesign.

//-- Tested with CS3, but should work with CS2 and newer

//-------------------------------------------------------------------------

//-- Purpose: To import the passed Tagged Text at the passed location.

//-------------------------------------------------------------------------

//-- Parameters: 2

//-- location: The location to place the file. Can accept anything

//-- that InDesign and InCopy will accept for the place function

//-- and it works in the same fashion as place.

//-- fileRef: A file object to the tagged text file to import.

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: true if the function was successful, or false if it was not.

//-------------------------------------------------------------------------

//-- Sample Use: Too many options to document.

//-------------------------------------------------------------------------

//-- Notes: In reality, this function will place ANY file. It doesn't

//-- test for tagged text files. But it does hard code some Tagged

//-- text import preferences.

//-------------------------------------------------------------------------

//-- Written: 2009.07.28 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Revised: 2009.09.13 for version 2.60 in New Orleans, LA to allow

//-- the placement to happen even if there is a dialog displayed.

//-- The problem was that the tagged text file can have missing fonts,

//-- and that really stops the script and throws a javascript error.

//-- Wrap the function in a try. The parameters can be setup incorrectly

//-- which will cause problems

try {

//-- Setup the Import Preferences for Tagged Text files

app.taggedTextImportPreferences.removeTextFormatting = false ;

app.taggedTextImportPreferences.styleConflict = StyleConflict.PUBLICATION_DEFINITION ;

//~ app.taggedTextImportPreferences.styleConflict = StyleConflict.TAG_FILE_DEFINITION ;

app.taggedTextImportPreferences.useTypographersQuotes = false ;

//-- Version 2.60 2009.09.13 prevent any user interaction.

var oaspuil = app.scriptPreferences.userInteractionLevel ;

app.scriptPreferences.userInteractionLevel = UserInteractionLevels.NEVER_INTERACT ;

//-- Now place the file -- simple. As a Text File that is marked as a

//-- tagged text file, it will just work.

var placeResults = location.place ( fileRef, false )

//-- Version 2.6 2009.09.13 return the user interaction levels

app.scriptPreferences.userInteractionLevel = oaspuil ;

//-- Check that the file was imported. This won't work when the wrong

//-- location is sent.

if ( placeResults == undefined ) { return false ; }

//-- implied else

return true ;

}

catch (err) {

return false ;

}

Find the Scripts Panel Folder

2009-10-07T08:03:00.002-04:00

Part of a Script to Install Scripts

I've been thinking for some time of a foolproof method of installing scripts at remote sites. Almost all of the script writing I do is done for sites that I never get to visit. The sites contract me to do the automation and I send the scripts and the invoice. Generally the installation process isn't a problem, but some sites have never looked inside the Adobe InDesign or Adobe InCopy application folder to see where the scripts get installed. And some sites don't have any managed approach to installing scripts other than walking around to each machine (it is actually hard for me to imagine that, but it is true). So to make things easier, I've wanted a script that would either self install or an installer script would do the installation.

This generic function is the start of that process. If your script contained something like:

#target indesign

var scriptsPanelFolder = findScriptsPanelFolder() ;

Then that 'scriptsPanelFolder' variable would contain a Folder object for the Adobe InDesign CS3 or CS4 Scripts Panel folder. Remember this isn't 'true' JavaScript where working with folders isn't allowed, this is ExtendScript where working folders is encouraged.

From that location, it would be easy to go up one more parent and test for the 'Startup Scripts' if you needed to install something there.

By the way, add a line like this:

scriptsPanelFolder.execute()

And that scripts panel folder will open. And that .execute() method works in Windows or Mac OS. It is both an ExtendScript File and Folder object method.

function findScriptsPanelFolder () {

//-------------------------------------------------------------------------

//-- F I N D S C R I P T S P A N E L F O L D E R

//-------------------------------------------------------------------------

//-- Generic: Yes, for both Mac OS and Windows

//-- any version of ExtendScript, but only for

//-- the CS3 and CS4 versions of Adobe InCopy or Adobe InDesign

//-------------------------------------------------------------------------

//-- Purpose: to locate the Scripts Panel for Adobe InCopy or Adobe

//-- InDesign when a script is launched from an unknown location

//-- (like the downloads folder). The reason is that if you want

//-- to use a script to install a script, this is a necessary part

//-- of the process. This function requires the user of a

//-- #target incopy

//-- or

//-- #target indesign

//-- line in the script file calling this function. Without that

//-- there will be nothing to signal the script where to start

//-- looking.

//-------------------------------------------------------------------------

//-- Returns: A Folder object for the Scripts Panel folder

//-------------------------------------------------------------------------

//-- Calls: Itself, the function is recursive.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var scriptsPanelFolder = findScriptsPanelFolder() ;

//-------------------------------------------------------------------------

//-- Written by Jon S. Winters starting on 2009.07.18

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- If the function was not passed any arguments, then start at what

//-- ExtendScript calls the 'startup' folder. This will be several

//-- layers deep within the Adobe Application.

//-- However, if the function was passed an argument there will be one

//-- and we want to use it as the starting point. This allows the

//-- funciton to call itself recursively. See the last line of the

//-- function to see the recursive call.

//-- Note: Wanted to use the alternative form of the If statement,

//-- but it wouldn't post on the blog, so the long form is here.

if ( arguments.length == 0 ) { var currentFolder = Folder.startup }

else { var currentFolder = Folder ( arguments[0] ) }

//-- Calculate the path for the 'Scripts Panel' folder from the curentFolder.

//-- Then check to see if that folder exists. If it exists, return to the caller.

var possible = Folder ( unescape ( currentFolder + '/Scripts Panel' )) ;

if ( possible.exists ) return possible ;

//-- implied else;

//-- If here, look one layer up from the current folder. Do this by

//-- calling the function recursively.

return findScriptsPanelFolder ( currentFolder.parent )

}

Safe for XML files

2009-10-05T10:34:00.000-04:00

I've been working more and more with creating and parsing XML files with ExtendScript. Came across a problem when trying to write a string that was enclosed in < and >

ExtendScript complained when asked to convert the file's contents to an XML reference that there was a missing tag. And it was correct, at least for its way of thinking.

So below is the quick little function to parse a string to convert the 4 reserved characters into their entity references necessary to write them.

Note, publishing this requires that a bunch of things get further escaped to post. I've got no idea how it will copy back out.

function entityReference ( str ) {

//-------------------------------------------------------------------------

//-- E N T I T Y R E F E R E N C E

//-------------------------------------------------------------------------

//-- Generic: Yes. Works for ExtendScript and likely for all ECMAScript

//-- and even JavaScript providing the Regular Expression converts.

//-------------------------------------------------------------------------

//-- Purpose: To replace the XML Reserved Characters in a passed string

//-- with their Entity References

//-------------------------------------------------------------------------

//-- Arguments: A string to clean up.

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: The string with the reserved characters replaced with their

//-- entitity references

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var unfitForXML = '< open & ampersand > close % percent'

//~ var safeForXML = entityReference ( unfitForXML ) ;

//-------------------------------------------------------------------------

//-- Notes:

//-- 1) You can add any other cleanups you need for your particular XML

//-- 2) Be wary of using something to excape the entity references

//-- prior to sending to this function as you will escape all the

//-- ampersands have have areal mess in the XML.

//-------------------------------------------------------------------------

//-- Written: 2009.10.04 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- replacing each individually to make it more portable and easier to read

str = str.replace ( new RegExp ('&' , 'gm' ) , '&' ) ;

str = str.replace ( new RegExp ('>' , 'gm' ) , '>' ) ;

str = str.replace ( new RegExp ('<' , 'gm' ) , '<' ) ;

str = str.replace ( new RegExp ('%' , 'gm' ) , '%' ) ;

//-- return to caller

return str ;

}

CS3 to CS4 observations

2009-10-02T12:24:00.006-04:00

I've been updating a few ExtendScript functions from CS3 to CS4. I've noticed two interesting cases where it could be argued that something is broke, but it is hard to tell.

When setting fonts for app.findTextPreferences.appliedFont or app.changeTextPreferences.appliedFont if you set that to a non-existent font in CS3 it would fail (the value would not get set and there would be an error). In CS4 it succeeds silently, well sorta. The value will get set, but since the font doesn't exist, the find or change event will definitely fail. Which is better? I like the CS3 result.
In CS3 if you a looking at a link to a file you can use .update() to import the link again. In CS4 you can't do that if the link isn't modified. I like the CS3 behavior because it allowed you to reimport a linked text file that has been modified in Adobe InDesign, but hasn't changed in the file system. Now in CS4 you have to use .place() on the frame.
Definitely an improvement here. In ExtendScript you can use $.level = 0 to ignore many errors. In CS4 this works. In CS3 it was pretty much ignored. $.level has three values 2, 1, 0. When set to 2 it even stops at errors that are enclosed in try blocks. When set at 1 it ignores those errors. When set to 0 it ignores most errors.
Another improvement in CS4 app.applyWorkspace(). Wonderful.

Collapse InDesign Text Frame to Descenders

2009-09-30T13:48:00.003-04:00

It used to be as I taught Adobe InDesign to QuarkXPress users that I would always get asked why Adobe InDesign collapses the frame to the baseline instead of forcing the frame to the descenders as QuarkXPress does. For whatever reason, I don't get asked the question much anymore, but this function will make Adobe InDesign behave the same as QuarkXPress, and maybe even better.

If you pass this function a reference to a text frame it will automatically collapse it to the position of the final descender. It is great for headlines. However, if you pass it a second argument, a real in points, it will add that number of points to the frame. Great if you still haven't adopted a baseline grid (baseline grids make building pages easy).

I wrote this function for a project nearly a year ago and I know it gets used every day multiple times by the client who uses it. Now anybody that wants it can have it too.

This function could very easily be given an alternate keyboard shortcut to replace the default

control alt c

command option c

keyboard shortcuts for Fit Frame to Content.

function holdDescenders ( aTextFrame_o , extraHeight_n ) {

//-------------------------------------------------------------------------

//-- H O L D D E S C E N D E R S

//-------------------------------------------------------------------------

//-- Generic: Yes.

//-------------------------------------------------------------------------

//-- Purpose: To increase the height of the passed frame by the amount

//-- that Adobe InDesign indicates is the height of the largest

//-- descender of the frame.

//-- Assumptions: 2

//-- 1: This function assumes that the frame has already been collapsed

//-- to the baseline of the last line of text as if you had used

//-- its 'Fit Frame to Contents' function. Call this function

//-- _after_ collapseing the frame using your desired method.

//-- 2: The measurement system is assumed to be points.

//-- Warning: There is no error checking for text that is not visible.

//-------------------------------------------------------------------------

//-- Parameters: 2

//-- aTextFrame_o: A single text frame object. The frame whose height

//-- you want to increase the height of by adding the maximum

//-- descender height.

//-- extraHeight_n: a point value. If not supplied, zero is assumed.

//-- Returns: Nothing. The passed object is modified.

//-------------------------------------------------------------------------

//-- Written by Jon S. Winters on 2008.10.29

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Verify argument 2. If it isn't a number, make it zero.

extraHeight_n = parseFloat ( extraHeight_n ) ;

if ( isNaN ( extraHeight_n ) ) { extraHeight_n = 0 } ;

//-- Get the descender value

var descenderHeight = aTextFrame_o.parentStory.characters[-1].descent ;

//-- Increase the frame height

var currentBounds = aTextFrame_o.geometricBounds ;

currentBounds[2] = currentBounds[2] + descenderHeight + extraHeight_n ;

aTextFrame_o.geometricBounds = currentBounds ;

}

Force Redraw Adobe InDesign

2009-09-24T10:15:00.000-04:00

An Adobe InDesign or Adobe InCopy user can press the key combination:

shift F5

to force redraw or update the display of the screen. This is good for removing screen artifacts or screen trash when the video display can't keep up with the user's changes. That won't help panels or palettes that aren't displaying correctly, but it does update the page(s) being displayed.

Some scripts can also make changes that the display cannot keep up with. For example, I was writing a script to alter the position of guides on a page and I thought it wasn't working. In reality, Adobe InDesign just didn't bother to redraw the screen to show the new position.

This function will force Adobe InDesign to redraw the screen by rapidly changing the view mode.

function forceRedraw () {

//-------------------------------------------------------------------------

//-- F O R C E R E D R A W

//-------------------------------------------------------------------------

//-- Generic: Yes for Adobe InDesign

//-------------------------------------------------------------------------

//-- Purpose: To force Adobe InDesign to redraw the screen when it

//-- won't on its own accord. In the GUI the user can press the

//-- Shift F5

//-- key combination to force a redraw, the the script interface

//-- doesn't have a similar function. This works to solve this for

//-- when a script alter's the document but the window doesn't

//-- properly indicate the change.

//-------------------------------------------------------------------------

//-- Arguments: None.

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: Nothing

//-------------------------------------------------------------------------

//-- Sample Use:

//-- forceRedraw() ;

//-------------------------------------------------------------------------

//-- Written: 2009.09.22 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Store and then clear the redraw preferences

var originalRedraw = app.scriptPreferences.enableRedraw ;

app.scriptPreferences.enableRedraw = false ;

//-- Store the original view setting. The view setting will be changed

//-- to force the redraw to happen.

var originalView = app.activeWindow.viewDisplaySetting ;

//-- If the view is anything but Optimized, switch to optimized. This is

//-- the view the greeks the display. It is FAST.

if ( originalView != ViewDisplaySettings.OPTIMIZED ) {

app.activeWindow.viewDisplaySetting = ViewDisplaySettings.OPTIMIZED ;

}

//-- Otherwise switch to Typical as it is the second fastest.

else{

app.activeWindow.viewDisplaySetting = ViewDisplaySettings.TYPICAL ;

}

//-- Return the window as it was found.

app.activeWindow.viewDisplaySetting = originalView ;

//-- Restablish the redraw settings

app.scriptPreferences.enableRedraw = originalRedraw ;

return ;

}

Compare Two Arrays

2009-09-23T09:09:00.000-04:00

The method below compares two arrays to verify that they are the same.

It is a method, so be sure to place it above or before any code that uses it.

It was written to compare two arrays of

pageRef.marginPreferences.columnsPositions from Adobe InDesign.

Array.prototype.isSameAs = function ( compareTo ) {

//-------------------------------------------------------------------------

//-- I S S A M E A S

//-------------------------------------------------------------------------

//-- Generic: Yes, quite. JavaScript or ExtendScript

//-------------------------------------------------------------------------

//-- Purpose: To compare two arrays to verify that they are the same.

//-------------------------------------------------------------------------

//-- Arguments: The array to compare to. This is a method, it is attached

//-- to the first array.

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: True if the arrays are the same, false otherwise.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var a1 = [1,2,3] ;

//~ var a2 = [1,2,3] ;

//~ var a3 = [1,2,'3'] ;

//~ var a4 = '[1,2,3]' ;

//~ $.writeln ( a1.isSameAs(a2) ) ;

//~ $.writeln ( a1.isSameAs(a3) ) ;

//~ $.writeln ( a1.isSameAs(a4) ) ;

//-------------------------------------------------------------------------

//-- Notes:

//-- The function expects the elements to exactly match, change

//-- !== to != to allow duck type matches.

//-- This is a method. It must be declared BEFORE / ABOVE any code

//-- that uses it.

//-------------------------------------------------------------------------

//-- Written: 2009.09.22 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Make sure the passed argument is an array.

if ( ! ( ( typeof compareTo == 'object') &&

( compareTo.constructor.toString().match(/array/i) != null ) ) ) {

return false ;

}

//-- Make sure the length of both arrays is the same

var masterLength = this.length ;

if ( masterLength != compareTo.length ) {

return false ;

}

//-- Now compare every element

for ( var i = masterLength - 1 ; i >= 0 ; i-- ) {

if ( this[i] !== compareTo[i] ) {

return false ;

}

//-- At this point the arrays must be the same.

return true ;

}

File Name Without a File Extension

2009-09-22T10:01:00.000-04:00

The following is a method for the File object in ExtendScript to allow your ExtendScript (Adobe JavaScript) to get the name of a file without the original file extension. I use this code to create .log files and .xml files with the same name as an existing file in Adobe InDesign, but it is useable for many other things such as getting the base name of an Adobe Photoshop file.

File.prototype.nameWithoutExtension = function() {

//-------------------------------------------------------------------------

//-- N A M E W I T H O U T E X T E N S I O N

//-------------------------------------------------------------------------

//-- Generic: Yes for ExtendScript. Not JavaScript.

//-------------------------------------------------------------------------

//-- Purpose: to return the name of the file without the file extension.

//-------------------------------------------------------------------------

//-- Arguments: None. It is a method.

//-------------------------------------------------------------------------

//-- Calls: Nothing.

//-------------------------------------------------------------------------

//-- Returns: The name without the extenstion or the original name if no

//-- file extension is used.

//-------------------------------------------------------------------------

//-- Sample Use:

//~ var fileRef = File.saveDialog ('Pick an Adobe InDesign File', '*.indd' ) ;

//~ var baseName = fileRef.nameWithoutExtension() ;

//-------------------------------------------------------------------------

//-- Written: 2009.09.21 by Jon S. Winters of electronic publishing support

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Get the original name ;

var fullName = this.name

//-- Locate the final position of the final . before the extension.

var finalDotPosition = fullName.lastIndexOf( "." ) ;

//-- check that position. If it isn't -1 (missing) return the text

//-- up to that position.

//-- Note, there are some odd things that can happen when passing

//-- a file reference that begins with a single dot. Be wary.

if ( finalDotPosition > -1 ) {

return fullName.substr( 0 , finalDotPosition );

}

//-- implied else, return the original name because there is no dot.

return fullName ;

}

Time Stamp

2009-09-21T08:10:00.002-04:00

This is a basic function to produce a consistent length time stamp within a script. This produces a time stamp in the format of:

yyyy.mm.dd hh:mm:ss.mss

The function was built to be included in a log routine, so it is very bare bones.

function getTimeStamp () {

//-------------------------------------------------------------------------

//-- G E T T I M E S T A M P

//-------------------------------------------------------------------------

//-- Generic: Yes

//-------------------------------------------------------------------------

//-- Purpose: To create a time stamp string in the format of:

//-- yyyymmdd hh:mm:ss.mss

//-- 2009/06/13 01:23:45.678

//-------------------------------------------------------------------------

//-- Paremeters: none

//-------------------------------------------------------------------------

//-- Calls:

//-- PadWithZeros: Internal function to pad with zeros

//-------------------------------------------------------------------------

//-- Sample call:

//-- var ts = getTimeStamp() ;

//-------------------------------------------------------------------------

//-- Returns: A string of the current time as yyyy.mm.dd hh:mm:ss.mss

//-------------------------------------------------------------------------

//-- Written 2009.09.20 by Jon S. Winters

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

//-- Use the Date object to grab the time right now

var now = new Date() ;

//-- Construct the full string

return (now.getFullYear() ) + "." +

PadWithZeros( now.getMonth() + 1 , 2 ) + "." +

PadWithZeros( now.getDate() , 2 ) + " " +

PadWithZeros( now.getHours() , 2 ) + ":" +

PadWithZeros( now.getMinutes() , 2 ) + ":" +

PadWithZeros( now.getSeconds() , 2 ) + "." +

PadWithZeros( now.getMilliseconds() , 3 ) ;

//-- End of main body.

//-- Next is internal function

function PadWithZeros( value , digits ) {

//---------------------------------------------------------------------

//-- P A D W I T H Z E R O S

//---------------------------------------------------------------------

//-- Generic: Yes.

//---------------------------------------------------------------------

//-- Purpose: To pad a number with zeros.

//---------------------------------------------------------------------

//-- Parameters: 2

//-- value: the number to pad

//-- digits: How many total digits should the number become

//---------------------------------------------------------------------

//-- Returns: A string version of the number padded to the number of

//-- digits specified. If the value is already that number of

//-- digits or longer, the value is returned.

//---------------------------------------------------------------------

//-- Calls: Nothing

//---------------------------------------------------------------------

//-- Written: 2009.09.20 by Jon S. Winters

//---------------------------------------------------------------------

//-- Change the number into a string

var paddedString = String ( value ) ;

//-- Check the length of the string. And continue adding zeros to the

//-- front until the desired number of digits is reached.

while( digits > paddedString.length ) {

paddedString = '0' + paddedString ;

}

return paddedString ;

}

//-- end of internal function

}

Verify or Create Folder Method

2009-09-20T10:15:00.007-04:00

One of the limitations of ExtendScript's Folder object is its inability to create a chain of folder paths. It has an .exists property and a .create() method, but each only looks at the final folder in the path. If you pass .create() a path that is several folders away from a parent folder that exists, the creation will fail. Each folder in the chain of folders must be created individually.

This function does that. There are two ways of doing this, build and parse an array like a stack or use a recursive function. This uses a stack.

Folder.prototype.verify = function() {

//-------------------------------------------------------------------------

//-- V E R I F Y

//-------------------------------------------------------------------------

//-- Generic: Yes

//-------------------------------------------------------------------------

//-- Purpose: A folder object method to verify if the folder specified

//-- actually exists. If the folder doesn't exist, the method will

//-- attempt to create it.

//-------------------------------------------------------------------------

//-- Returns: True if the folder exists, false if it couldn't create it.

//-------------------------------------------------------------------------

//-- Sample Call:

//-- Folder ( '~/IsItHere' ).verify() ;

//-------------------------------------------------------------------------

//-- Calls: Nothing

//-------------------------------------------------------------------------

//-- Written 2009.09.19 on board US Airways flight 4376.

//-- eps@electronicpublishingsupport.com

//-------------------------------------------------------------------------

if ( this.exists ) {

return true ;

}

else {

//-- Create an array like a stack of folders that will need

//-- to be created.

var foldersToCreate = new Array () ;

//-- Create a local copy of the original folder

//-- because it needs to be modified within

//-- this routine.

//-- Using the absoluteURI version of the name to point

//-- all the way through to the sever. Only this version

//-- of the activeFolder needs to use this absoluteURI

//-- notation because.

var activeFolder = new Folder ( this.absoluteURI ) ;

//-- Loop through the path structure until every part of

//-- of the folder path is checked. Any non-existanet

//-- folder path will be added to the array to create.

while ( ! activeFolder.exists ) {

//-- Add the activeFolder to the array of folders to create

foldersToCreate.push( activeFolder ) ;

//-- Now get to the parent of the folder.

//-- Can't use .parent because if the active folder

//-- doesn't exist, it won't have a parent.

activeFolder = new Folder ( activeFolder.path ) ;

}

//-- At this point we have an array of folders that need to be

//-- created. The array will have one element too many because

//-- of the final line of the

while ( foldersToCreate.length > 0 ) {

//-- Remove the last item added to the array of folders to create

activeFolder = foldersToCreate.pop() ;

//-- Try to create this folder

if ( ! activeFolder.create() ) {

return false ;

} //-- end of if create

} //-- end of lower while

} //-- end of else from way up top

//-- At this point the folder has to exist else we already returned false

return true ;

}