Standardizing Standards 4: Publishing Standards Using STS

Transcript

ERIC DAMITZ: Hello, and welcome to "Standardizing the Standards: Publishing Standards Using STS."

My name’s Eric Damitz, I’m a Senior Solutions Consultant with Typefi. I’ve been with Typefi since 2014. Before that I worked in educational publishing
for about 20 years, so my area of expertise is on the production end of both print and digital outputs for various publication types.

In the last webinar, you saw how to get your content into STS. So in this one we’re going to show you how to take that STS and produce different
deliverable formats that you can give to your customers. And we’re going to do that using Typefi.

So what Typefi does, is we can take various types of input files. We can take XML that’s created using eXtyles, we can take STS XML created in
whatever authoring platform, or we can also take Microsoft Word, or a variety of other authored documents.

We then convert that input format to what we call Content XML, which is an intermediary XML format that our system uses to produce all the different
kinds of outputs that you might want.

We can take that CXML and send it to InDesign, and using InDesign we can produce InDesign files that can be published to EPUB or PDF or HTML.

We can also go directly from that Content XML to any other kind of XML you might need. We can go directly to EPUB, or directly to HTML. And we
can also publish to the DAISY format.

So, using one source file, you can get as many different outputs as you would require.

What we’ll do now is look at what that source XML looks like. This is an STS XML file—it was created using eXtyles so the authors worked
in Word and they used eXtyles to do all their editorial work, and then when they were finished with the file they exported it and we get this
nice XML file.

We have all of our tags, we have all our metadata, and we have all of our content in here. We have links, and images, and math, and all kinds of
stuff that you would expect to find in a file like this.

I can then take this XML file and publish it using Typefi.

So now we’ll move over to Typefi, and before I do any of this I’ll just let you know that I’m running this demo on a laptop computer, so I’m not
using some super-computer or anything, this is just my laptop.

I’m using Typefi Desktop which is one of the ways that you can use Typefi; we also have server-based products that would run much more quickly
than what you’re about to see on my laptop here.

This is the Typefi web interface, and I have this project set up. I have XSLT transforms, I have some InDesign templates, and then the content
and images are also on the server here. And then I have this workflows folder.

I have two workflows set up, and these are completely customisable—you can set up whatever kinds of workflows you like. And a workflow’s
job is to take a source file and turn it into whatever output file you want.

This PDF workflow is set up to take that source XML file we just looked at, and produce an InDesign PDF from it. If I check that box there and
hit Run Workflow it’ll ask me which source file I should use, so I’ll just click my little folder here, and I can either browse my local file
system to grab that, or if I happen to want to store it on the server I can grab it from here as well.

So here’s the file that we were looking at, and I’ll hit Run.

What will happen is that source XML file is converted to Typefi’s Content XML, and it’s sent to InDesign. An InDesign template will be opened and
then all of the content of that source file will be placed in InDesign, and it’ll be styled according to how the template was set up.

Some other things that are going on as the pagination happens—the math is being brought in as MathType images, those are going to be placed
correctly so that they sit on the baseline of the text. They’ll be centred on that baseline if they’re taller than a line, and they won’t crash
into the paragraphs above or below.

We’re also running Typefitter, which is a plug-in that we sell. Typefitter can do typographical tweaks to the content, and they’re based on situations
that you would like to fix as you’re running the pages. This one is set to get rid of widows or short lines at the end of paragraphs. And when
we open this file after it’s done running I can show you where it’s actually done that.

You can see it’s just putting some math in there now, and then there’s a figure. You can bring in whatever kinds of images that InDesign can handle,
can run through Typefi.

We’re basically using InDesign, and kind of controlling it and laying out the pages automatically.

Something else that’s happening here—if a table spans a number of pages we have a script running that adds the table continuation text at
the top, so if you have long tables that go page after page, all of those can be automatically laid out.

So that is our InDesign file. It’s now going to open that InDesign file again to produce a PDF, and once that PDF is created we can take a look
at it.

The reason we’re going with InDesign here, is it’s essentially the most used page layout software out there. Pretty much everything you’re going
to buy at a newsstand or a bookstore is going to be created using InDesign.

There’s a huge user community, there are a lot of people, a lot of designers, that know how to use InDesign, there’s plenty of training available.
InDesign is, like I said, the most widely used software for page layout, so that’s why we use that.

Here’s our InDesign file, and I just wanted to show you right here, this orange highlight, this is non-printing so you won’t see this in the output,
but it’s an indicator that Typefitter has run this paragraph up. There was just a small amount of text on the next line here, so it ran that
back so it’s in the spec of this design. Same thing with this one.

If we look at the PDF that was created, I’ll go to my job folder. This is again the Typefi server; after the job is done you can click on this
job folder and all the files that were created during the production of this job are here, so you get everything, we’re not hiding anything.

Here’s the source XML file, here are those intermediary XML formats I was talking about before, here’s the InDesign file, and then here’s our final
PDF. So I’ll open that.

And we’ll take a tour through this PDF, but before we do that I’m going to run this EPUB workflow in the background, so it’ll be finished by the
time we’re done looking at the PDF.

Same idea, I’m going to take that same source file, but now I’m running it in a workflow that will produce an EPUB instead of a PDF.

So our PDF has quite a few little features in it. This is actually an accessible PDF, and you can see we have bookmarks, so these are all automatically
populated in here. These are, of course, all clickable, they’ll take you to whatever page that these different objects are on.

If we go back to the table of contents, these are also clickable links in the table of contents, and then all of the URLs in here are clickable,
all the cross-references to other sections of the document are clickable.

This one goes to the references, another cross-reference to a document item. So everything has been automatically added here to make this a very
usable and interactive PDF.

We’ll zoom in on the math a little bit here. You can see that it’s been set correctly so that it’s centred on this baseline, rather than smacking
into all of the equations above and below it. All of that spacing has been managed through the system to make sure that the output looks good.

And then we can also see, as I mentioned while the job was running, we had these table continuation notices. So this table goes to the second page
here. This text here and the table title is repeated automatically, so you don’t have to go in and manually add all of that sort of thing.

This one has some custom table rules, and we can also support custom shading of cells so if you have specific cells that you need shaded in a table,
all of that can be done based on the source file coming in.

I can show you some of the accessible features as well. This is the tagged text, so all of this information is tagged properly for accessibility
purposes, so each of these stories is actually tagged right.

And then all of the document metadata has been set—so you can see, for example, the initial view has been set, and then all of the different
metadata has been set up.

If I run the accessibility checker here we get a report back, and it passes accessibility. There’s a few issues that you’ll have to look at, some
of these are manual things that you would have to check manually anyway.

So just a pretty automatic way to set up a file and get that accessible PDF and interactive PDF out.

Our EPUB is done now. Again, here’s my output folder, and I have all my files, and here’s my EPUB. I’m going to open this one on my Mac, so if
I go to this folder here, I had this job copy the file onto my laptop.

If I grab that and open it up on my e-book reader, you can see we have a nice-looking EPUB from that same source XML that we made the PDF with.
These, of course, are all clickable as well.

And then some of the benefits of an EPUB. Of course, you can do a search on this, you can change the type size if you want to. You can highlight.
And then you can add bookmarks as well. So, of course that’s going to depend on which e-reader you’re using, all of those features, but the
EPUB itself, that format allows you to do those sorts of things.

And you can see we have the nice-looking math, and here’s our figure, and then here’s those tables in the end. They don’t have any rules because
that’s the design of this particular EPUB.

So those are two of the formats that we can pretty easily create using STS XML as the source, and then using Typefi to create those outputs.

I’ll show you another one really quickly. This is a different standard that we ran through a different job. This is a DAISY file, so what Typefi
will do is output all of these different components of that DAISY file.

Again, we’re starting with that same XML, or an XML file, and running it through a DAISY export to create all of these different files. And then
when I open this up in the DAISY reader…

SCREEN READER: Sidebar has focus. Section. Design for access and mobility part 4.2. Means to assist the orientation of people
with vision impairment. Wayfinding signs. Paused.

ERIC DAMITZ: So you can see this tool that we’re looking at here is actually sort of a DAISY QA tool. The actual users of this
have devices that they can use, sort of like play and pause buttons, to hear the reading of the book.

All the data from this content is brought through, set up in this format, and all of this is now readable. It’s in the correct reading order, and
then if there are images in here, it will actually read the alt text for this image.

You can see I’m hovering over it here; you can see all of that alt text in there. That would be read to the person who’s using this file.

So again, it’s another output that can be created from that source XML.

Now we’ll take a quick look at how all that worked. The first thing we need to create a file like that is a template. To create the PDF file we
have an InDesign template, and I’ll flip over to that one now.

Here’s the standards template that we used. Of course there’s no pages in here yet, this is a changelog here. We use the same template to create
every standard, in this case it’s the standards that ISO produces.

And some of the features of this template, you’ll notice we have all of these different kinds of covers. All of the different kinds of documents
that are produced, are all produced through this one template.

So you don’t need hundreds and hundreds of templates if you have different document types; as long as the base body text and the design is similar
between them all, you can use one template to produce all these different things.

Another feature—we have all these different layers for different languages. And we have a JavaScript that turns on and off these layers depending
on what language you’re producing. Again, you have one template that can have all these different possible outputs running through it.

And then, of course, because it’s a design-based tool, we have all of our styles—so all these different paragraph styles, this controls the
look of the text. We also have table styles, so if you have different kinds of tables with different borders or different shading or different
specs around them, all of those can be added here.

Of course, none of this is Typefi-specific, these are all just things that InDesign does anyway. So if you’re already in an InDesign workflow,
you could take the template you already have and then add Typefi markup to make it an automated template.

And some of that Typefi markup—we have Typefi Designer, which is our InDesign plug-in, and that lets you set up things like Typefi sections,
and you’ll see all these different cover sections, and then we have our main content section and so on.

This is how we determine which master pages to use, and what the pagination should be. Should it start on a right-hand page? How does the page
numbering look? All of that information is stored here.

We also have Typefi elements, and an element is a smaller-than-the-whole-page type thing. If we look at this template, we’ll see that there’s some
element pages in here.

We have all of these cover note elements, so different types of covers have these different notes that can be placed on them. They’re all placed
in the template here, and as a particular job is run, if a specific one of these is needed it’ll be grabbed from this page and put onto the
actual page that is published through the job.

We have a figure element. This is just an empty frame here, and depending on the size of the image that goes into that as the job is running, this
frame will kind of shrink to fit that image and be placed correctly. And if the image is larger than this frame, the image can actually be
resized so that it doesn’t stick off the side of the page. So there’s a lot of control over how the design looks using these elements.

This one actually is also set up for redline. If you run a redline job through this, this green box will be sized and placed above any additional
content, and this one will be placed on top of content that’s been removed. I don’t have a demo for redlining, but that is definitely something
that this system can do.

Again, if there’s a new figure it’ll have a green line around it, and if there’s one that’s been deleted, it’ll have the x through it. These are
just brought up and placed on the actual layout pages as the job is running.

You use the Typefi plug-in as well to add all of these elements to the template. And again, these are all customisable, you can name them whatever
you need to, and you can have as many or as few as you need, it’s completely up to you.

So that’s our InDesign template, and once that’s created and everything’s working, you can run any job through it and get the output that you’re
looking for through that template.

I’ll go back to the Typefi system here and show you what this workflow contains.

This is our PDF workflow and we’re bringing in our STS file here—it’s asking me which one, that’s why that screen popped up and said which
file do you want—and we’re creating a CXML output, and we’re using this transform.

So the transform will take a certain kind of XML and turn it into a different kind of XML. There’s a basic STS transform and then you can tweak
it as needed, depending on how you implement STS.

Each one of these little boxes is called an action, and I have a representation up here in the toolbar. When I add one to here, I can reorder them,
and I can add whichever ones I need. This is adding some tags, so these were those blue boxes in the job folder.

That’s the EPUB, I’ll go back to the PDF one.

Then we have another step where we’re applying conditions, so the XML has certain sections that should be omitted in certain cases, so if you want
to omit those you’d turn that on and run the job, and they’ll be left out of the file.

After that step, we’re creating the InDesign document, and this is the actual software that runs InDesign. Here’s the template that we just looked
at, so we’re telling it which template to use, and we’re saying what version of InDesign.

And then in this tab we have what we call event scripts, so these are additional little programs that change the pagination based on your needs.
So, at each of these steps in the process of paging the document, at the start of a document, at the start of each section, at the start of
a spread or a page, or at the end of all those, you can kind of pause what the Typefi layout engine is doing and inject a little additional
programming to make that layout exactly what you want it to be.

And then once that InDesign file’s created we send it to the Export to PDF action and that creates our web-ready PDF based on the Adobe preset,
and of course these are also customisable—you can have whatever ones you need.

And then we have a final step where we update the metadata, and this is to make it fully accessible, so here we’re adding the metadata that accessible
PDFs require, and we can also set the initial view when you open the PDF, right here.

So that’s a pretty simple workflow. The EPUB one is very similar. Again, we’re taking that source file, add a few tags, do our omit condition.

In this case we’re doing another transform, because we need to change a few things, because an EPUB is very different from a PDF, of course. The
code behind it is different and the usage of it is different, it’s reflowable. So we’re changing a few things in the CXML.

In this case we are creating an InDesign document again using a different template, so this is optimized for EPUB output. And then we have an Export
to EPUB, so we’re kind of using InDesign’s EPUB Export tool, filling in all the metadata that you would use in InDesign, and we have a lot
of different things to set up here, a lot of different options you can do.

So you set up all of this, it’ll generate the EPUB, and then the last step is the Cleanup EPUB. InDesign makes notoriously questionable EPUB code,
and this helps clean that up to make the files smaller, make them a little nicer as far as the way that they’re coded goes.

And then my last step here was just to copy that file onto my other computer.

So that’s another fairly simple workflow. I could’ve combined these into one workflow—so maybe I have a final workflow where I produce both
of these at the same time, that’s totally doable.

In fact, we can have fairly complicated workflows if they’re needed. Here’s an example of one. You can see this one has quite a few steps in it.

This is a specific action that this particular customer wanted to be done, so we made them a custom action—only they get to use this one.
Their input file is actually a ZIP file that contains XML and images and all the supporting documents that they need to produce their output.

This specific action here takes a ZIP file as its input, and then it gives you an XML file as its output.

The next step then is similar to what we saw before, where we’re turning that into CXML using this transform. Adding a tag. In this case we’re
editing some metadata, so you can manage metadata in the XML file, and if you need to override things during a job you can do that here, or
you can just allow the values to pass through from the XML, and that’s how this one is set up.

Then we have conditions here again that omit, that we saw before. We’re creating InDesign. This is a specific kind of InDesign document—this
is content with the DOIs included—and then we’re exporting to PDF, and this is the one with the DOIs, it’s accessible.

Then we’re going to update the metadata, again, to make it accessible.

So this file that we’ve created here, this PDF, is going to have live DOIs, and it’s going to be accessible, and it’s going to be optimized for
viewing on the web, and then again have those live DOI links.

We’re going to take that same source file that we imported at the beginning. Now we’re going to create a version that doesn’t have the DOIs. We’re
going to go through that metadata step again, apply conditions again.

We’ll create a new InDesign document, this doesn’t have DOI links in it so the pagination might change slightly—we just don’t want those
in there.

So, new InDesign file, another export to PDF, another update metadata, so now we have our web-optimized accessible PDF file that doesn’t have those
links in it.

And then we’re going to run a script on that no-DOI InDesign file that we created, and that’s also going to be exported to PDF, and this is the
one that goes to press.

And then we’re going to run another script on that same file, produce another PDF, and this is the version of record of that particular PDF.

So we’re creating four PDF files from this one source input. The only thing the user has to do is tell it which job to run, which input file to
use. It’ll run through all of these steps automatically, and then at the end they have another custom action that zips all of those up and
puts them on a specific server via FTP.

So you can have a very automated workflow where you have lots of different outputs all running at the same time. They can be brought in from a
server, you can do it manually—however you want to get them into the system.

And then once all those outputs are created, you can put them somewhere you want to, you can download them individually; however you want to work
that, we can set up a workflow to manage that.

So that is the extent of our demo.

Some of the benefits of a system like this are we can take those STS source files and use them to create all of the different outputs you want.
Because we have set up the templates beforehand and all of these transforms, once that XML is available you can much more quickly get those
publications out.

And you can get them out simultaneously. It’s no more creating the print version, then sending it to someone, waiting awhile, and getting in the
electronic version, whether it’s an accessible PDF or an EPUB or a DAISY file. It’s all done at the same time.

You can produce those multiple outputs, again including EPUB, HTML, redline versions, DAISY, XML, PDF, whatever you need, all at the same time
from the same source file.

And you can continue to use the same tools that you’re already using. So Microsoft Word, either alone, or Microsoft Word with eXtyles to create
XML. Whatever authoring tool you’re using, we can take those files and create the outputs for you.

And it does significantly simplify the workflow. Instead of having a multitude of vendors or those documents changing lots of hands, going through
different departments, you can set it up so that you have one input file, one set of images, run them through, and then you get all of your
outputs from the same place.

Thanks very much for watching. You can see our web address down there for more information on other webinars in this series, and have a great day!
Thank you.