As usual, this post is a literate Haskell file, so you can try it out by saving it to Inkscape.lhs, compiling with ghc --make Inkscape, grabbing the source file for the images above, and running ./Inkscape < demo.svg. The output will appear in Slides.pdf (and your directory will be polluted with temp files, so be aware).

For the record, multi-page documents have been on the Inkscape feature request tracker for many versions, so I presume it is a significant change. I do grok C and C++, thanks to the legacy-oriented education system, but take little enough pleasure from them that I would rather hack around the issue in Haskell.

> import Text.XML.HaXml
> import Text.XML.HaXml.Pretty
> import Text.XML.HaXml.Posn
> import Text.PrettyPrint.HughesPJ
> import Text.Printf
> import Data.List
> import System.IO
> import System.Cmd

HaXml is based on a combinator library for CFilters to filter, search, output, etc XML content. It is a little crufty in some ways — many datatypes are transpararent, and you have to do a lot of your own set up and tear down. The expected way to use it seems to be via processXmlWith :: CFilter -> IO () which is not sufficient for today’s task. The Hackage documentation pointed to an old version of the API, so I used the current version of the source code for documentation. I’d love any criticism like “you didn’t have to do X” or “here is an easier, safer way to do Y”.

I couldn’t think of a better way to narrate this code, so I’ll start with main for a high-level read, and then later fill in all the helper functions. Naturally we start with a call to xmlParse; the "-" is a required filename for error reporting.

> main = do input <- getContents
>           let xml = xmlParse "-" input

Then I grab the names of all the layer objects in the order they appear in the file, except for the special layer “Background” which I’ll include behind every slide. The call to verbatim spits them out as Strings instead of XML Content, and the "-" is yet another required filename for error reporting.

>           let names = delete "Background" 
>                       $ map verbatim 
>                       $ filterElem "-" getLayerNames
>                       $ xmlElem 
>                       $ xml
>           putStrLn $ "Making slides from layers:" 
>                        ++ concatMap ("\n\t"++) names ++ "\n"

Then for each layer, make a new version of the file with just that layer visible.

>           let outXmls = map (flip selectLayer xml) names
>               usedSlides = take (length names) slideNames
>           mapM_ (uncurry writeFile) 
>                 (zip (map (++".svg") slideNames) 
>                      (map (renderStyle xmlStyle . document) outXmls))

And some shell scripting done in Haskell. I didn’t even try to find a scripting library or anything to e.g. prevent me from building a malformed command.

>           mapM_ (\slide -> do 
>                    system $ "inkscape --export-text-to-path --export-pdf='" 
>                             ++ slide ++ ".pdf' '" ++ slide ++ ".svg'")
>                 usedSlides
>           
>           system $ "pdftk " 
>                      ++ concat (intersperse " " (map (++".pdf") usedSlides)) 
>                      ++ " cat output Slides.pdf"

So now to the little details:

Grabbing the layer names

Here is the first helper I wrote, wrapping HaXml’s attrval for a common case. This filter returns every tag whose attr attribute has the string value val.

> matchAttrString :: String -> String -> CFilter i
> matchAttrString attr val = attrval (attr, AttValue [Left val])

The next helper is one that maps a tag to its attribute value, otherwise discards anything else it sees. The HaXml function iffind will pass the attr attribute value of a tag to literal which just returns it. If the attribute isn’t found, or the XML data isn’t a tag, then none will discard it.

> showAttr :: String -> CFilter i
> showAttr attr = iffind attr literal none

The Inkscape layers are contained in <g inkscape:groupmode='layer' ...> tags. The name of the layer is in the inkscape:label attribute. I imagine this will change as Inkscape evolves. The o is the composition operator for CFilters.

> isLayer = matchAttrString "inkscape:groupmode" "layer"
> getLayerNames = showAttr "inkscape:label" `o` isLayer `o` children

Isolating the layers

Again proceeding from the outside of my program inwards, a layer is isolated with this helper, using iffind to match either the layer name or the layer “Background” which I’m going to leave in all the output files. The final keep argument to iffind says to keep parts of the XML that don’t have the "inkscape:label" attribute.

> selectLayer :: String -> Document Posn -> Document Posn
> selectLayer layer doc = onContent "-" (chip (visible `o` onlyLayer)) doc
>     where onlyLayer = iffind "inkscape:label" layerOrBG keep
>           layerOrBG l = if l == layer || l == "Background" then keep else none

In writing visible I was surprised that there was a combinator to set all attributes for a tag, but none to set a single attribute.

> visible = setAttr "style" "display:inline"
> setAttr key val (CElem (Elem tag attrs cs) i) = [CElem (Elem tag newattrs cs) i]
>     where newattrs = (key, AttValue [Left val]) : filter ((/= key) . fst) attrs
> setAttr key val other = [other] -- Hackish?

As I mentioned before, there is no way that I see to directly apply this filter to an XML file using HaXml. The type CFilter = Content -> [Content] needs wrapping to apply to an XML Element directly. Notice how I have to pass in a file for error reporting; it feels like I’m doing things I’m not supposed to.

> filterElem :: FilePath -> CFilter Posn -> Element Posn -> [Content Posn]
> filterElem file f e = f (CElem e (posInNewCxt file Nothing))

> xmlElem (Document _ _ e _) = e

And now the function to actually apply a filter to an XML document. This is straight from the body of processXmlWith in the HaXml source, with filterElem pulled out.

> onContent :: FilePath -> (CFilter Posn) -> Document Posn -> Document Posn
> onContent file filter (Document p s e m) =
>     case filterElem file filter e of
>              [CElem e' _] -> Document p s e' m
>              []           -> error "produced no output"
>              _            -> error "produced more than one output"

Bits and pieces

I also used a modified style for the HughesPJ pretty printer

> xmlStyle = style { mode = LeftMode }

And a big list of slide names with three digits, for this one-off job. Better would be to use an API for generating fresh temporary files.

> slideNumbers = map (printf "%03d") ([1..999] :: [Int])
> slideNames = map ("Slide"++) slideNumbers

Kind of lame, but it took me a minute to figure out: To get TeX to search different directories, you need to set the TEXINPUTS or TEXINPUTS_latex to a normal colon-separated path. That Kpathsea is its own library shows how much higher-level modern languages are!

In my poking about I also discovered that teTeX is no longer updated, and it seems TeXLive may be the most “modern” tex distribution. It appears to have the relatively insane distribution method of downloading a DVD image and mounting it locally, probably related to being kind of Windows-centric, but also downright weird and old-fashioned (who installs from anything but the net?). The XeTeX program looks nice for being able to input unicode to TeX, something that I failed to figure out a couple of years ago. Since I have various TeX-involved deadlines, I won’t be trying anything new for a couple of weeks.

• WhizzyTeX – realtime preview of TeX in a separate window. This synergizes the idea of GUI word processing (the important part of WYSIWYG is realtime visualization) and markup languages (which beat all GUI’s hands-down in terms of ease of editing complex documents).
• preview-latex – has an “edit” mode where you hack latex, then when you leave edit mode it renders a little preview. I haven’t tried it in depth yet.
• AucTex – A nice LaTeX major mode (or so I hear)

Some stuff that Leslie Lamport wrote would be nice if it didn’t conflict with every other style file; I edited it to remove the conflicts and I’m using it now.

http://research.microsoft.com/users/lamport/latex/latex.html Also, since we are regularly pushing proofs to appendices:

http://tug.ctan.org/cgi-bin/ctanPackageInformation.py?id=thrmappendix