In this example we will look at taking from an EasyCatalog field we have named Mustache, some JSON/hash style code and transforming it with a Mustache template into a HTML table.

The field data is made up of various fields representing the attributes of a car.

The field called Mustache has the check boxes for both "Formatted" and "HTML" marked with the "Enhanced" selected.

With the "Preprocessing" tab selected the "Method" Mustache is selected. In this area we put our template code to build the HTML table from the fields.

The field "Mustache" is placed into a text box in our document.

The final result is a nicely formatted table using a JSON/hash source of code.

This example is a 4 column x 1 row table that will display 1 record.

To set the row options select Table → Row Options with the row highlighted.

Select Record.

With the cell selected click Table → Cell Options and change the "Field Specifying Stle Name".

This is the final result.

In this example we will take delimited text from a field and convert to HTML table in a custom field using the custom reference FORMATASTABLE.

You can see the delimited text (comma seperated) in the field TV_CSV.

The delimited text field TV_CSV has had some "cleansing" applied to it to remove the paragraph markers.

A new custom field Table_TV has been created.
In the Contents: parameter the field TV_CSV field contents are imported, and processed by the FORMATASTABLE command.

The result is table rows (<tr>…​</tr>) and table columns (<td>…​</td>).

However, it is still not a full HTML table.

To make it a full HTML table, we must use the Prefix: and Suffix: in the field options. While doing that, we can also apply a table style to our final table.

The <table>…​</table> tags are now added.
The table style CunkaStyleTable has also been added.

A text frame is added to the document page, and the field specifier Table_TV is inserted into it.

One thing that we have forgotten is set the field options of Table_TV up so it knows the content is HTML text.

The final result shows how FORMATASTABLE has taken the delimited text and created a HTML table, styled and looking nice on the page!

In this example we will look at an existing field called CunkaTV_XML that contains a XML snippet. We will transform the XML with an XSLT stylesheet into a HTML table via new custom field.

Our XML snippet is an example of a product that has a root “cunkaTV” field containing detailed technical specifications about the product.

We have an existing XSL style sheet to do the conversion from XML to HTML. The file is called features.xsl.

With the XSL file features.xsl, it is importnant it is stored in a place EasyCatalog and our data source panel can find it.

Within the EasyCatalog "Workspace" folder there is a folder for the data source panel. in this case "CUNKA Test Panel". Within that folder Easycatalog has created a folder called "XSLT". The file features.xsl is saved in the "XSLT" folder.

Create a new custom field called Cunka_XSLT_table and put the "Contents:" APPLYXSLT(CunkaTX_XML,'features.xsl')

This custom command takes the XML from the field CunkaTX_XML, processes it to HTML using the file features.xsl and saves it in the new custom field Cunka_XSLT_table.

The table will be formatted using HTML style tags, so its important to make sure the field Cunka_XSLT_table uses it properly.

On the "Format" tab make sure the checkboxes for both Formatted & HTML are selected, and the dropdown box is set to Enhanced.

The result shows he new custom field Cunka_XSLT_table and a preview of the HTML formatted table.

Now we add a text frame to a page in our document, and insert the field specifier Cunka_XSLT_table.

The final result shows when a row is dropped into the text frame, the HTML table appears formatted nicely.

In this example, we will create a table using LUA and put it in a tabular table field.

Here is my data source panel called "CUNKA Test Panel".

Our goal is build a a 4 column table from the fields:

We want to filter our records down to build a table using the GROUP_COLOR field. So we can have a table of only the "GREEN" colors.

The field PRICE_1x10 will not only display the price, it will be used to sort the records from lowest to highest when filtered.

The first thing we need to do is create a new custom field called color_LUAtable.

In the "Format" tab we set Tabular and the "Source:" to be Command Script.

Now press the "Configure" button.

The next screen is where we enter our LUA code.

Just for your own sanity, we do not use that tiny window to program the LUA code into EasyCatalog/InDesign.

I use Sublime Text or VSCode as my programming editors where I can edit my code. I then copy and paste that into the EasyCatalog dialog window and press "Test".

Here is the LUA code pasted in.
The "Test" button has been pressed and there is a preview of the table at the bottom.

This is how the new custom field color_LUAtable looks in the data source panel. I have one of the "GREEN" records open to show the table preview.

Next we need to put a text frame on the document page, then insert a 1x1 into it.

With the table selected , Table > Table Options from the EasyCatalog panel menu we apply the following settings for the table.

The result on the page looks like this.

This example uses the following HTML table code in the field HTML_Table.

The HTML code uses styles/classes that equate to cell/table styles in InDesign.

Field Option settings for HTML_Table have "Formatted" & "HTML" check boxes both selected, and the dropdown box set to "Enhanced".

The field HTML_Table is placed into a text box.

A table has been pre-designed with the table/cell styles.

The final result shows the HTML table as a nice formatted InDesign table.

In this example a HTML tabular field called Tabular_HTML has been created. The contents of the HTML can be shown on the panel preview below.

On the document page, there is a single row, single column InDesign table.

To set the table up to use the EasyCatalog tabular field, the "Table Options" need to be selected.

Final result on the page is a nice formatted table. (Assuming you have included styles in your HTML)

This example is the same as Example 1 with the exception that an InDesign table is not used, and the tabular field is placed directly into a text frame.

The final result is the same as in Example 1.
Its recommended to see best results using the method outlined in Example 1.

In this example, we will take CSV formatted text from a field into a tabular field to generate a table.

The field CSV_Data contains the raw CSV formatted text.

A custom field called my_CSV_Table is created to pull in the contents of the CSV_Data field through the command FIELDSTR(CSV_Data).

The tabular field settings are located in the Field Options under the "Format" tab.

We need to help EasyCatalog out a bit and know a little bit ourselves about how the CSV text is constructed.

CSV text usually divides its infomation in columns and rows by using a comma as the column seperator, and a carriage return as a row seperator. Due to the flexibility with what you can use to seperate with, EasyCatalog will need to know what our text will be formatted in.

Select the "Configure" button to set up the row/column delimiters.

Due to the formatting of the text, there can be additional characters in our text which will mess things up. As a quick example, paragraph end markers/symbol.

To remove the paragraph end marker & paragraph symbol, we need to use the "Cleansing Options" from the EasyCatalog metacharacters list.

Next , set up the document.
Simply put a text frame on the page and add a new table with 1 row / 1 column.

Select the table and set up the "Table Options" in EasyCatalog. The set up is as follows.

When we drag and drop a record on to the table, the CSV text now appears as table on the page.

This can be improved by supplying a Table Style.

The table style CUNKA_CSV_TABLE will now be applied to the table. To do that we will do it through the field my_CSV_Table and not the table itself.

The reason being in the Table Options the set up we applied said When Populating: Create New Table. So any style applied to that table will be removed when we apply the field my_CSV_Table. To fix that, we simply get the field my_CSV_Table to apply the table style.

In the field options for my_CSV_Table under the "Format" tab, click on "Additional Processing".

This takes you into the area where you can do additional processing of the table through the LUA programming language and preview it.

Its very simple and easy for any designer to do!

The code we will be using can simply be cut/paste into any similar tabular fields. The only thing you need to know is how many heading rows are in your table, and the name of the table style you wish to use.

Just note the color of the preview area for now.

Here is the LUA code to copy/paste in.

To test the code, click on the "Test" button.

You will notice the top row is now shaded darker. This darker shading indicates a "row heading".

Press "OK" when finished.

Now when you drag and drop a record on to the table you will see a nicely formatted table.

In this example, we will take 3 fields from the existing data source panel (it could easily have been from another data source panel) and use them to create a new custom tabular field to create a table.

Our panel is made up of colors with a fake part number and price that will wrapped up into a table.

The 3 fields in the table taken from the "CUNKA Test Panel" are:

The field GROUP_COLOR is used to to tell the data source tabular field how to group the table.

First thing we do is to create the new custom field. I’ve given it the name myColor_DataSource.

On the Format: tab of the new custom field, we set it to "Tabular" and set the "Source:" to Data Source.

We then press the "Configure" button.

The "Table Field Configuration" dialog appears.

This screen may initially be a little confusing, so lets take a little time to explain it.

The whole use of "Tabular" > "Data Source" is very flexible. We can not only create a table from fields from within our current data source panel, but we can create a table from any other existing data source panel.

So there has to be a field that could be used as a "key" to indicate how the data will be grouped. Once you have that field, you can then say to any data source to look at a particular field of its own to try and match between the two. If there is a match, then use it as a row in the table.

Just so happens that field GROUP_COLOR was set up to group the colors together, so I’m using that as my "key".

Firstly I select the Data Source panel we want to match to. This is the existing data source panel "CUNKA Test Panel".

This will give us a list of "Available Fields" to choose from.

The fields I want checked and matched against are the GROUP_COLOR field.
eg.I want to group all the "RED" colors together…​"BLUE" colors together.

From the "Available Fields" we can now now select our "Chosen Fields".

Because we are creating the custom field, there is no preview of the table. However, we can sneak a view of it by pressing the "Additional Processing…​" button.

You can now see a preview of the table.

Press "OK" when finished.

This is the new custom field myColor_DataSource in the "CUNKA Test Panel".

A text frame is created on the document page, and a 1x1 table is inserted into it.

With the table selected we edit the table options and use the following settings

When we drag a row to the table from the data source panel we get the following table of all the colors from the GROUP_COLOR field matching "RED".

That pretty much is all there is to creating a datasource tabular table.

However, we can think about improving how it appears and changing a few things.

Go back into the field options of myColor_DataSource and press the "Additional Processing…​" button. This will allow us to change a few things relating to the generated table.

We can look at sorting the columns of the table. To do that we can use some LUA code.

All the code is pretty simple to use and can be reused in your tables. The only requirement is to understand the values been used so you can change them to your own needs.

Lets first sort the 1st column into a alphanumeric order.

Here is the LUA code to copy/paste in.

This LUA code simply tells the table an "alphanumeric" sort will be applied. Start at column 1 row 2.

Why row 2?
The first row contains the column headings. Which you can see in the preview as a darker shade of grey.

To see the results of the code press the "Test" button.

The preview now shows the result of pressing the "Test" button.

We can also apply a "numerical" sort.

This LUA code tells the table a "numeric" sort will be applied. Start at column 3 row 2.

Here is the LUA code to copy/paste in.

Press the "Test" button to see the result.

We can also apply a table style.

I have already created a table style called CunkaStyleTable_Datasource to apply.

To simply change the table style I use the code:
table:setstyle('CunkaStyleTable_Datasource');`

Here is the LUA code to copy/paste in.

Unfortunately, you cant preview the table style. You will need to test the result on the table in the document page.

The result is a nicer looking table.

However, I still have those field names as headings in the table. They dont look appealing at all and go against a design ethic of making it easy to read.

If go back in and do some "Additional Processing…​" we can look at changing those headings with some more simple code.

We only need to know the row and column, and we can change the contents (in the table cell).

eg. changing the first column heading is simply table:cell(1,1):setcontent('Color Name');

Here is the LUA code to copy/paste in.

Press the "Test" button to see the column headings change in the preview.

The final result of that table on the page.

It is now sorted, has a better appearance and more readable column headings.

In this example, we will take this EXCEL spreadsheet, and create a table from it.

We may need to use many EXCEL spreadsheets, so we have a field called EXCEL_filename that simply contains the name of the EXCEL spreadsheet.

A new custom field is created called Excel_TV.

On the Format: tab of the new custom field, we set it to "Tabular" and the "Source" to Command Script. We next press the "Configure" button.

We simply paste this LUA code in and press the "Test" button to preview the result.

Lets take a closer look at the code and break it down into simple small steps.

This line of code gathers where the EXCEL file is located on my PC. It grabs the file path as well as the file name. Just so happens the filename is in a field called EXCEL_filename.
path = "C:/_my_files_folders/"..field('EXCEL_filename');

The next line is where the EXCEL table is created from the filepath/filename.
table = TABLE.newexcel(path);

This line simply applies a pre-designed InDesign table style to the new table.
table:setstyle('CUNKA_TV');

The last line says the table has been fully built and is ready to be presented on the page.
table:present();

This is the new custom field Excel_TV in the "CUNKA Test Panel".

A text frame is created on the document page, and a 1x1 table is inserted into it.

With the table selected we edit the table options and use the following settings.

The final result showing the EXCEL spreadsheet has been imported and table has been created from it.

In this example, the XML snippet is loaded into the field CunkaTV_XML.

Our XML snippet is an example of a product that has a root “cunkaTV” field containing detailed technical specifications about the product.

The XML is built up of a root element called cunkaTV that contains the technical Features elements. Each Features element has an attribute1 and attribute2 fields. Where attribute1 contains the name of the feature, and attribute2 contains the feature value.

The first step is to create a new custom field to be our tabular field.

I’ve named the new custom field XML_table.
In the Contents: window we import the contents of the field CunkaTV_XML.

On the Format: tab of the new custom field, we set it to "Tabular" and the "Source" to Field Content. Set the "Field Content Type:" to XML.

Press the "Configure" button.

The Edit XSL dialog window appears.
This is where the XML is transformed into a HTML table.

At this point, you will now just have to press OK, and create the custom field. The reason being you cant really get a good preview of the data at this stage.

When you have created the field, come back to this stage and you will see the screen shot with a preview of the XML data.

Here is a preview of the XML data.

This is the source XSL transformation to paste into the XSL Stylesheet:.

Press the "Test" button to see a table preview.
Press "OK" when finished.

Press the "Additional Processing…​" button.

In the Post Processing dialog we can do some additional work on the table. So we will use one of my existing table styles and apply that to the tabular table we have created.

Press "OK".

Next we create a text frame and insert a 1 x 1 table.

With the table selected we edit the table options and use the following settings.

Press "OK".

The transformed XML can now appear in the table.

A typical usage would be where the source data contains a XML snippet in a field that needs to be output as a table.

For example each product may have a “cunkaTV” field containing detailed technical specifications about a product. This could be loaded into the field as an “XML Fragment” via the XML Data Provider.

In this example, the XML snippet is loaded into the field CunkaTV_XML.

The XML is built up of a a root element called cunkaTV that contains the technical Features elements. Each Features element has an attribute1 and attribute2 fields. Where attribute1 contains the name of the feature, and attribute2 contains the feature value.

On our document page we create a text frame and insert a 1 row x 2 column table.

Here is what the table looks like on the page. It has a predefined table style applied.

With the table selected, we select Table > Table Options in the panel, we apply the following settings:

To apply our XSL transformation press "Edit".

The top window of the Edit XSL dialog has a preview of the XML data.

In the next window called XSL Stylesheet: we put the following XSL transformation code.

The XSL simply uses a for-each repeating loop to go over every Features and create columns for each attribute1 and attribute2 to create a HTML table.

Press the "Test" button to see a preview of the table.

Here is the final result where the XML has been transformed into a HTML table and applied to the table.

A matrix table is a ‘look up’ table that expands both horizontally and vertically. They are usually read as the rows as the source, and the columns the destinations. However, its possible to change this around. Train time tables are a good example of a matrix table.

In EasyCatalog, the amount of rows and columns is determined by the number of unique values in the specified fields.

When using Reuse Existing Table you already know what InDesign table style you are using (its possible to change) and the amount of columns in the table.

If the table has only 3 columns and there is 5 columns of data, then 2 columns will not appear.

When you have tables that have variations in the amount of columns, and you would like to control the styling of the table, then Create A New Table is a great choice. However, it does require a bit more work to set up and use.

With a pre-existing table select Table Options > Cell Options.
You can then define all the cells or a range of cells preset behaviours like Horizontal Merging or Vertical Merging.

By default both Horizontal Merging and Vertical Merging are set to Do Not Merge.

New tables (usually from tabular fields) require some additional processing to merge cells. Since the table is new, EasyCatalog/InDesign has no idea how you want the cells to be handled. So some simple reusable LUA code is used.

Through the "Additional Processing" (Post Processing) dialog its possible to do anything you need to a table through LUA code.

This LUA code for instance simply takes all the cells across all the columns except the first row (which is a header), and does a verticalmerge on the condition ifcontentmatches.

It then sets the InDesign table style I have created called Safety_Glasses, to be the style of the table.

The Quick Selection Table (or the Quick Reference Table) is a type of table that conveys information so the reader can easily make a decision.

Tables can sometimes appear with a dense amount of data with much of the information somewhat repeated through repetition or similarities.

As a designer, you will know that information can be cleaned up and presented that enhances the readers experience.

With Quick Selection Tables you will see (as an example) a lot of Yes/No attributes in a table. A designer can quickly turn those columns graphically into a cleaner table where the user can scan,analyze, compare with ease.

Before attempting a Quick Selection Table, always have a mockup of how you would like tables to appear. While it may seem obvious, you will surprised at how often it can make the work take longer then it should if it is not done.

If you are replacing text with characters like ticks, crosses, circles, boxes, hollowed shapes, then always know what font you plan to use and importantly what unicode number is used for that character.

The examples all begin looking like the preview in this screen shot.