How to Define a Plug-in

Wikipedia defines a plugin as “a set of software components that adds specific capabilities to a larger software application”. Not a bad definition.

Most software applications have very specific ways of adding functionality to the application, and this definition pretty much covers it. In InDesign, things get much more confusing, because it’s probably one of the most extensible commercial software applications in existence!

In the beginning of time (a few years back when InDesign was created), there were “plugins” and “scripts” — two very well defined concepts.

Plugins

Plugins were written in C++ using the same SDK and APIs that InDesign itself was created with. In fact, at least 90% of InDesign itself and almost all its features are implemented as plug-ins. Plug-ins are tightly integrated into the program, very efficient, and can work dynamically in the background. Plug-ins can have user interfaces which look like integral parts of the program.

Scripts

Scripts are implemented in one of the three supported scripting languages: ExtendScript (Adobe’s version of Javascript), Applescript (on Macintosh), or Visual Basic Script (on Windows). Scripts were classically slow, each action showed up separately in the undo list, they must be manually invoked, and they were limited to clunky, static user interfaces.

Although InDesign had incredible scripting support (there’s almost no native functionality that can’t be accessed through scripting — and better), there were many clear use cases where a true plug-in was the clear (and only) choice.

On the other hand, scripts are much quicker and inexpensive to develop, as well as easier to debug. Additionally, a buggy script is much less likely to crash InDesign than a buggy plug-in.

Things Got Muddled

As InDesign matured, the scripting engine became more powerful and capable. Each version of InDesign brought a quicker, more efficient scripting engine. In recent versions, except for the most demanding procedures, you can hardly tell the difference between the performance of a “native” plug-in, and an optimized script. Of course the performance of the script will highly depend on how it was written, but a veteran script writer should know how to write scripts that run efficiently.

On top of that was the introduction of events, and Script UI. Events allowed for scripts to run dynamically in the background and Script UI allowed for user interfaces which reacted dynamically to user input and context.

The division between “plug-ins” and “scripts” became very blurred. The only clear differentiating point remained the language the add-on was written in. Plug-ins are written in C++, while scripts are written in one of the higher level scripting languages.

The only two use cases where “plug-ins” remained the clear winner, is where functionality was needed that didn’t exist at all in InDesign, or very high performance was critical.

Hybrid Plug-ins

These distinctions are further blurred by the fact that an add-on does not need to be 100% “script” or 100% “plug-in”. It’s quite possible to mix C++ code with scripting code to create a seamless product (and quite a few of these products exist!) The starting point of such code can be a “script” or the whole thing can be compiled into a single plug-in. It is entirely invisible to the user whether a specific feature is implemented as a “scripting feature” or as a “plug-in feature”. In fact the implementation can be split up into a custom implementation like was done with APID (which we utilize in our products).

Enter: “Extensions”

In CS5, Adobe introduced a new concept: “Extensions”. Extensions can be written using the CS SDK. They are programmed in Flex and ActionScript, and compiled as swf applications. These extensions are an entirely new class of “add-ons”. They have all the capabilities of AIR applications, and all the functionality of integrated scripts. Script Bay is one example of such an extension. Mini Bridge, CS Review, and Kuler are other examples.

Extensions have many of the UI advantages of plug-ins, and can be contained inside native panels. There are quite a few new events in CS5 which allow even tighter integration into the program. In addition, “extensions” can work across the different programs of the Creative Suite.

Conclusion

The basic fact remains. There’s many ways to extend InDesign, and there is no clear “right” way to do it. Sometimes it makes sense to implement a feature as a plug-in. Other times it makes sense to do it as a script, other times, a hybrid, or custom solution is required.

In many situations, it is even difficult to define whether a specific add-on is a “script” a “plug-in” or something else. That fact is, that to the user, it doesn’t really matter that much what the definition of the product is. The technology used to create add-on functionality is mostly a developing consideration. From a user perspective, it’s just important that it allows the user to do what they need!

If you are purchasing a commercial “add-on” don’t concern yourself too much with the technology used to create it.

If you need a custom solution created, things are a bit different. Make sure that whoever you hire is familiar with all these technologies, or you might end up paying extra money for a product which could be created cheaper using a different technology.

The most obvious improvement is the way settings are set. In previous version of Column Flow, the column settings had to be set by changing the style names. Now column settings can be set using a much more intuitive dialog:

But beyond that, there’s a whole pile of tricks that you can now do with Column Flow that was not possible before. Just to illustrate some of the improvements, we will show the previous configuration dialog followed by the new one:

Old Column Flow Settings

New Column Flow Settings

However to really appreciate what Column Flow can do for you we’re going to discuss the Span Columns feature of CS5 a bit.

When we first learned about the Span Columns feature of CS5, we had some real doubts about updating Column Flow for CS5 compatibility. Span Columns is the feature that people have been asking for years, and we developed Column Flow to fill that need. Now with Span Columns, Column Flow is no longer needed. Or so we thought…

After studying Span Columns however, we came to a very different conclusion. In our opinion, the Span (and Split) Columns feature is perfect for newspaper and advertisement layout. For long-document layout however, we believe it falls short of being the needed solution. Here’s why:

• Span Columns works dynamically. This is great, you say. Right? Well for short articles, yes it is. But for long stories? Not so much. Very long stories can have quite a few column breaks along the way. Even with the incredible job the engineers at Adobe did to optimize the code of breaking the columns, it can be very processor intensive, and editing text at the beginning of a long story can quickly become a very tedious job! Additionally, dynamically created column spanners can be very difficult to adjust. To change the spacing on specific pages would require paragraph-style overrides (if it can be done), which makes the file error prone.

• Span and Split Columns gives very little control over keeps options, and very often keeps are completely ignored to prevent columns from having no text. This can make flowing text correctly extremely difficult!

• Trying to use Span Columns to create a section of text which will always stay together (i.e. keep all paragraphs together) is virtually impossible. InDesign does not have the ability to leave a text column empty. To force a whole section of text to the next page would require manually resizing the text frame — which defeats the whole point of Span/Split Columns.

• There’s no way to ensure that a section of text starts on the baseline grid. You need to set the paragraph style to Align to Grid. This is not a solution which will work for headings which must be aligned to grid only at the top of a column.

• There’s no column-balancing functionality included in Span/Split Columns. If it balances, good. If not? Try to balance it yourself.

• Span Columns only helps within a single story. There’s no way to do cross-story spanning.

• Span Columns does not supply a solution for boxed sections of text.

• Because Span Columns uses one text frame for all the text, transparency settings cannot be applied to headings.

Column Flow addresses all these issues:

• Column Flow does not work dynamically, and we believe that for long documents this apparent disadvantage is really a plus!

• Column Flow gives very precise control over keeps with three different levels of strictness to give you your preferred balance between type-fitting and adherence to keeps rules.

• Column Flow gives an option to keep specific numbers of columns together as a unit, so it will not break across pages.

• Column Flow gives precise control over whether text sections are snapped to the baseline grid. This ensures proper alignment of heading text which is normally not baseline aligned.

• While Column Flow will not balance columns in every situation, Column Flow does performs more column balancing than Span Columns. It can even make pages one line long or short if necessary to balance the columns.

• Column Flow can create spanned headings even across different stories when the Story Tools plugin is used to set up Story Strings.

• Column Flow allows for boxed sections to be created with a border or background.

• Because Column Flow creates a separate text frame for each section, transparency effects can be applied automatically to headings specifically.

Additionally:

• When Column Flow is used in conjunction with AutoFlow Pro, master pages can be automatically applied.

Right now, Column Flow can be downloaded as part of the Layout Tools package here.

Full information on the plug-in may be found in the manual here.

Here are some screen-shots displaying some of the advanced functionality of Column Flow, with and without other In-Tools plug-ins included in the InBook plug-in package:

Illustration of several InBook components working together

Boxed Text Section Created by Column Flow

Hebrew layout

There’s quite a few new features in many of the InBook/InSefer plugins. We’ll try to get some documentation up over the next few days.

We’ve done only basic testing so far, so these should be considered public beta.

For now here’s direct links to download the updated plugins:

For CS5 compatibility you need the newest version of APID available here:
Macintosh Windows

• InSefer: Macintosh Windows
• InBook: Macintosh Windows

• AutoFlow Pro: Macintosh Windows
• Drop Words: Macintosh Windows
• Formatting Tools: Macintosh Windows
• Layout Tools: Macintosh Windows
• Power Headers: Macintosh Windows
• Proper VJ: Macintosh Windows
• Reflective Objects: Macintosh Windows

The existing version of World Tools should work with CS5 as-is, but we will soon be releasing a new, improved version.

These are both very commonly requested features, and we’re really happy to finally getting them added. This brings the total number of really useful utilities included in Formatting Tools up to seven. (“Conditional Paragraph Style Changer”, “Style Between Delimiters”, “Create One and Two Line Styles”, “Restyle Consecutive Paragraphs”, “Apply Next Styles”, “Create Hyperlinks From URLs”, and “Change Case By Style”.

You can download the new version of Formatting Tools from here for Macintosh and here for Windows

Installation:

Unzip the files, and drag the whole “Formatting Tools” folder to your plug-ins folder. If you don’t have APID installed, make sure to download it from here and install it.

Create Hyperlinks from URLs will automatically create hyperlinks from any text it recognizes as a valid URL. It’s very smart, and will ignore manually inserted line breaks on long URLs as well.

You can select the character style to apply as well as the scope of text to change (Document, Story, or Selection).

Change Case by Style will change all text with the specified style(s) to the selected case.

There are four different options: UPPERCASE, lowercase, Smart Title Case, and Sentence case. Uppercase, lowercase, and sentence case are the same results you would get by changing the case manually. Smart Title Case, is (as the name suggests) very smart! It will automatically convert text to title case based on complex rules!

The rules which the title case uses are as follows:
The first and last words are always capitalized, as well as any word following a period (full stop) or colon. Any compound word separated by a “/”, “.”, dash or m-dash will have the letter immediately following the separator capitalized. Any other word will be capitalized unless it appears in the _title_lowercase.txt file. Any word appearing in the file will be lowercase only if it is not a “starting” word. For example: In the title, “The Last of the Mohicans”, the first word “the” will be capitalized, while the second time “the” appears will not. This is because the first word is the beginning of the sentence. Similarly, in the title, “Lion: The King of the Jungle”, the first word “the” will be capitalized because it follows a colon. The lowercase word file can be edited to include any words you like. All words should be separated by a single space.

Any word appearing in the _title_specialcase.txt file will always be capitalized exactly as it appears in the file, regardless of position. This is useful for words like “InDesign”, “USA”, “UK”, etc., which have capitals in the middle of the word. This file can also be used to force lowercase on specific words and override the default rules. So, let’s assume you would like the word “a” to always be lowercase, even if it is the first word in your header text. You would simply put the word “a” in your special case file, and it will always be lowercase. When a word appears in both files, the special case file supersedes the lowercase one.

The Smart Title Case of Formatting Tools uses the same logic as the Smart Title Case of Power Headers, and you can (and should) use a single set of text files for both plug-ins. If the text files are placed anywhere within the plug-ins folder, they will work. You can also place the files somewhere on your hard disk, and create shortcuts/aliases in the plug-ins folder to the files.

You can select a paragraph style, a character style, or both for options of which text to convert. You can also select what scope of text to convert (Document, Story, or Selection). If neither a character style or paragraph style is selected, all the text in the selected scope will be converted.

FiddleScript — Your tool to fiddle with scripts (without having to fiddle too much).

Download the script from here.

If you are using CS4 or later, you can download the Extension Manager installer instead from here.

Compatibility:

FiddleScript is compatible with InDesign CS3 and higher.

Manual Installation:

1. Download the zip file from here.
2. Unzip the file.
3. Place the resulting file (FiddleScript.jsxbin) in your Script Panel folder.

• There is a Scripts Panel folder in your application folder, as well as your user data folder either one will work. If you want the script to be accessible by all users, make sure to put it in the main application folder.
• For more information on how to locate your script folder, please read this help file here.

Extension Manager (CS4 or later) Installation:

1. Download the .mxp file from here.
2. Double-click on the file, and the Extension Manager will install the script into your main Scripts Panel folder.

• The mxp installer file is designed to work with Adobe Extension Manager Versions CS4 or later. If you have other versions of Creative Suite products installed there is a possibility that your operating system may associate mxp files with an earlier version of the Extension Manager and will try to use that when you double-click the file. If that happens you will see an error alert similar to the one pictured below:
  
  If you do, make sure you use the “open with..” option (by right clicking on the file), and open with the correct version of Extension Manager (i.e. Extension Manager CS4).
• Alternately, you can open the Extension Manager, and click Install as shown below.

Usage:

To run FiddleScript, double-click on the script in your Script Panel. This will bring up a dialog like the one shown:

1. Copy the script code from wherever you got it, and paste the code into the text area.
2. To see the results of the script, click Run Script. If you are using CS4, you will be able to undo the whole script in one step.
3. If you are happy with your script, just click Save Script, type in a name, and your script will be saved to the Scripts Panel.

Some Quick Pointers on Using FiddleScript

• You can click on Load Script to populate the text area with code from a saved script. This is great for making a quick edit on an existing script without ever leaving InDesign. When you are done editing, Just click on Save Script, and you can save it back to your Scripts Panel. You can use the same name to overwrite the original script, or choose a new one.
• After saving a new script to the Scripts Panel, you will need to refresh the Scripts Panel display for it to become visible. To refresh the Panel display you can either close it and re-open it, or switch away from InDesign to another program, and back again.
• The current script will be saved for subsequent runs of FiddleScript. This makes it easy to check the script (or run it numerous times), without having to paste the script into the dialog each time.
• You cannot type a return or tab character into the text in FiddleScript’s dialog. If you need to type a return or tab, use the buttons at the top of the dialog.
• FiddleScript can make your saved script undoable in one step in CS4 and later. To facilitate this, it can wrap your script in a function which can be run in CS4 and later as a single step. By default, the undo Name will be “Run Script”, but you can change it to whatever you want by replacing “Run Script” at the end of the wrapper to whatever you’d like it to be called.
  

  After Wrapped the Script in a Function

“Number Lines by Style” is a script which allows you to add line numbers to text of specific styles. I works by adding anchored text frames at the start of each line. The script will number lines on the current page only.

“Number Lines by Style” was written in its original form for Koren Publishers we thank them for their consent to share it!

Please download the script from here.

Usage

1. Place the script in your Scripts Panel folder
2. Make sure the correct page is active
3. Double click on the script in the Scripts Panel
4. Select the style or styles to number and click OK.

Examples of Use

Here we have a shopping list of the most important things that you could possibly need.

We want to number the list items, so we run the script, and select the Numbered Lines paragraph style:

Which numbers our items:

Of course the example is kind of silly, because we can just use paragraph numbers. The one situation similar to this, where you might want to use this script, is when you’d need the numbers outside the text frame.

A more classic example would be a sitaution where you’d need every line numbered, and the paragraphs are more than one line long:

In this case, you’d run the script and select all the styles used in the essay:

Presto! numbered lines:

• The script uses an object style for the anchored text frames, as well as a paragraph style for the numbers within the frame. You can adjust these styles to tweak the positioning and formatting of the numbers.

Have fun!

This update fixes various bugs, and all users should update.

Please download the update from the downloads page.

Quick Reference is a script created to simplify the process of creating cross references. Thanks to David Blatner on his helpful suggestions when we were creating this script. You can read more about Quick Reference on InDesign Secrets here.

Creating cross references in InDesign is a somewhat painful process. You need to find the destination, and create a destination anchor. You then need to select the source text and create the new cross reference. You can also use references to text without anchors, but that’s even more painful to create.

We created Quick Reference to make this process less painful. To use Quick Reference, you just select the source text, and Quick Reference will give you a list of potential destinations. You just select the correct one, and hit enter. Quick Reference will do the rest of the work for you.

Installation:

We are including two different files for download: a zip file of the script, and an Extension Manager “mxp” file. You can use either one to install the script. Please download one (or both) of the files from here: Extension Manager File or Zip File

Installation using Extension Manager:

Installation should be as simple as a double click on the “MXP” file.

If you have CS3 installed, you might get an error when trying to open the file such as the one shown:

This is because Extension Manager (CS3) is trying to open the package and does not recognize CS4. If you get this error, you will need to install manually or to change the default application which opens the mxp file to Extension Manager CS4.

To install manually, open Extension Manager CS4 and click on the install button shown:

Once Extension Manager installs the script, you can enable and disable the script in Extension Manager:

If using Extension Manager is too much trouble, you can install the script manually.

To do this, download the zip file and decompress it.

You’ll need to place the whole folder as-is in you main scripts folder:

Usage:

Using Quick Reference is easy.

1. Select Source Text:
   

   Select Source Text

2. Select Create Quick Reference:
   
3. Select the destination in the dialog:
4. When you have the correct destination selected, hit Create, and you’re done!

A few tips on the use of Quick Reference:

• You must select the correct Cross Reference Format to use for your cross reference. (You can create or change them in the cross reference panel.) The selection should be the last format used in your document
• Quick Reference will either replace the current selection with a cross reference, or append the cross reference to the end of your selection. You should select the correct radio button.
• Quick Reference ignores trailing punctuation and spaces. If you want punctuation and/or space between the selected text and the cross reference make sure you select the trailing punctuation and/or trailing space.
• The listing of destinations will usually be in order within the text, so the correct destination will usually be the top one on the page.
• If the document is part o a book and the book document is open. Quick Reference will find destinations in the entire book. When this is the case, the name of the destination document will appear in the list of destinations.

Before we go on, make sure you download the scripts from here.

Situation #1

You have a headline which must fit to the margin widths. It may even be a two line heading. What to do?

“Fit Text To Frame” to the rescue!

Before

After

There’s two scripts which are used in this situation: FitTextPrefs, and FitTextToFrame.

FitTextPrefs allows you to set some simple preferences for the Fit Text to Frame script. When you run FitTextPrefs, you get presented with a dialog with four options:

The first two options will expand the text frame down to the bottom baseline or descender respectively only if necessary.

The last two options will move the frame bottom either up or down to fit the frame bottom ensuring that the frame bottom always fits the text.

Once we set the preferences, a simple double-click on the FitTextToFrame script will fit the text of the current frame.

Some quick pointers on using Fit Text to Frame:

• Fit Text to Frame will attempt to bring any overset text back into the text frame. This might result in more than one line.
• If there are multiple lines in the text frame, the text of the longest line will be fit to the frame. All other text will be scaled proportionally.
• Text of different sizes will all be scaled proportionally.
• If all the text cannot be fit, Fit Text to Frame will abort.
• Fit Text to Frame does not adjust leading. If there are multiple lines, it usually works best if the leading is set to “Auto”.

Situation #2

You have the unlucky job of fitting a story into a predefined space. You tried to explain to the client that to properly fit text takes a lot of finesse and very often copy-editing, but they won’t hear of it. You will need to fit the text exactly to the text frame precisely 30 seconds before it goes to press.

Fill Text Frame to the rescue!

Before Fill

After Fill

Fill Text Frame is really very basic. It will scale all the text currently in the frame to the maximum size that will fit in the frame without spilling out of the frame.

• Fill Text Frame will not bring back any text which is overset.
• Fill Text Frame scales all the text proportionally.
• Fill Text Frame does not adjust leading. It usually works best if the leading is set to “Auto”.

The script can be downloaded from here, and it supports InDesign CS3 and CS4.

The options are pretty straight-forward:

1. Scaling: You can select the horizontal and vertical scale, that you would like to make the images.
   • Next to the horizontal and vertical scaling fields, there is a check-mark labeled “Relative”. If this check-mark is checked, the images will be scaled to a percentage of their current size. If the check-mark is not checked, the scaling will be done to absolute values.
2. Image Offset: You can set an offset for the images. Please note: The images will be offset — not the graphic frame which contains them. This might change the way an image is cropped.
3. Location: Images can be scaled/moved on the current page, spread, or the entire document.
4. Relative Location: The graphics can first be centered before they are scaled. If “Centered” is selected, the graphics will be centered within their frames.
5. Fitting: There are 6 fitting options, which besides for “None” correspond to the fitting options available in the Object menu.
6. Limit to Images: If this check-mark is checked, only raster images will be scaled or moved.