Bovine Spirit

Find Fixtures Without Thinking

spam@matthewwest.co.uk(Matthew West) — Mon, 17 Sep 2007 00:01:25 GMT

This is a good trick I use on the Jands Echelon and the Hog 2 when I don’t know how a rig’s been patched. The problem is to find out where individual lanterns have been plugged in without having to think about it too hard. To start with I create a group of all dimmer channels, called ‘All Dimmers’. If I’m feeling nice I’ll fade the group up to around 15% for a while to let the fixtures warm up. Then I’ll select the group and press <Highlight>. Next up I’ll step through the individual lanterns using the <Next> button. When I find one that’s a Source 4 I press <@> <Full>. Once I’ve stepped though all the fixtures all the Source 4s are on at full blast. I then press <Active> <@> <Full>. This loads all fixtures at 100% into the programmer. I can then save a new group called ‘All S4s’.

Now that I’ve found all the Source 4’s, I can then find all the Par Cans, Pin Spots and whatever else is lurking in the rig. To select the lights I’ll use 'All Dimmers' <-> 'All S4s'. This selects everything but the Source 4s, I can then find all the Par Cans and save that as a group.

Once I have my groups of lanterns I can then subdivide them. If I’ve already found all the Source 4s I can select them, and set all the Source 4s that I wish to use as a dappled wash to 100%, then use <Active> <@> <Full> to select them before saving the new group. I can then use 'Source 4s' <-> 'Dapple' to select the remaining Source 4s that I wish to use as spots, and save that as a group.

The important thing to remember is that if any masters are on with fixtures at full then those fixtures will also be loaded into the programmer by <Active> <@> <Full>. If I’m leaving lights on for working light etc then I put those masters at 80%.

The end result is that I have all the lanterns arranged into useful groups that I can either use to create HTP masters or include into more complicated programming without having to remember or write down a single channel number. The disadvantage is that I cannot grab individual fixtures if I’m getting glare etc. In practise this isn’t too much of a problem.

Bush Hall Reviews

spam@matthewwest.co.uk(Matthew West) — Mon, 04 Jun 2007 00:40:59 GMT

Lucky Soul’s gig at Bush Hall got some very good reviews, a couple even mentioned the lighting… Some fabulously purple prose from BBC London:

Few can resist shimmying along as the room is transformed into a snow globe of light and magic, complete with twinkling fairy lights and glittering disco-ball.

Twinkles and glitter? Maybe I should do less weddings…

Links: The Independent, The Guardian, BBC London, ArtRocker

Lucky Soul at Bush Hall

spam@matthewwest.co.uk(Matthew West) — Sun, 27 May 2007 19:19:49 GMT

Lucky Soul played their biggest headline gig to date at Bush Hall, London on 16th May, 2007. Starlight Design generously provided 2 Mac 550s, some pealights, an Echelon and various other bits and bobs for me to light them with. I also used the house rig.

I didn’t have time to take any photos, but there are loads on Flickr. The lighting was very ‘photographer friendly’ as the band were hoping for some press interest, which seems to have worked out. The pealights worked well at the time, as they gave a nice backdrop for the band. Most of the photos seem to have been taken from the front looking up at the remarkable Bush Hall ceiling which I lit using the Mac 550s.

Having seen the band in some smaller venues I was interested to see how they’d cope with something bigger. With a better PA and a bigger room and audience they seemed to move up a gear and they played a blinder. The whole show had more kick, and they seemed to grow to fill the space. Hopefully they’ll be counting Bush Hall as a small gig soon enough…

Photo Links: 1, 2, 3

XSL Contents

spam@matthewwest.co.uk(Matthew West) — Mon, 16 Apr 2007 02:35:24 GMT

While I was building this website, I thought it would be nice to put a contents page on pages that have multiple sections, such as this one. This would allow people to jump directly to the section that they were interested in, as well as providing a summary of the page. Updating the contents page manually soon became a chore, and I would often forget, or make spelling mistakes that stopped it from working. What was needed was a way of creating contents pages automatically. As I was already using XSLT to create the pages to a standard template it seemed the best way to create the contents list would be to use XSLT.

The Problem

What I wanted to do was to take a document that was structured like this…

<h3>Heading 1</h3>
<p>Text</p>
<p>More text</p>
<h3>Heading 2</h3>
<p>Text</p>
<p>More text</p>

...and transform it into something like this…

 <ul>
  <li>
   <a href="#Heading_1">Heading 1</a>
  </li>
  <li>
    <a href="#Heading_2">Heading 2</a>
  </li>
 </ul>
 <h3 id="Heading_1">Heading 1</h3>
 <p>Text</p>
 <p>More text</p>
 <h3 id="Heading_2">Heading 2</h3>
 <p>Text</p>
 <p>More text</p>

As you can see the contents list is contained in an unordered list, and each list item contains a link to the heading, using id tags. The headings have had their id tags automatically inserted. The id tag names are taken from the headings, so that it is easy to link to them from other pages. However it should also be possible to specify an id tag.

First Attempt

For the initial attempt I’m going to assume that the headers already have id tags, and look like this…

 <h3 id="Heading_1">Heading 1</h3>
 <p>Text</p>
 <p>More text</p>
 <h3 id="Heading_2">Heading 2</h3>
 <p>Text</p>
 <p>More text</p>

I’m also going to assume that the XSL template copies the body of the document across ‘as is’...

 <xsl:template match="html">
   <xsl:copy>
     <xsl:apply-templates select="*" mode="BodyCopy" />
   </xsl:copy>
 </xsl:template>

 <xsl:template match="*" mode="BodyCopy">
   <xsl:copy>
     <xsl:apply-templates select="*" mode="BodyCopy" />
   </xsl:copy>
 </xsl:template>

The mode attribute allows different templates to match the same elements at different times. Thus the above template ensures that all elements are copied when in ‘BodyCopy’ mode. In order to insert the contents somewhere useful we’re going to define a new element type. This will not be copied into the final document, instead it will be replaced with the contents table.

 <xsl:template match="contents" mode="BodyCopy">
   <ul>
     <xsl:apply-templates select="html/body/*" mode="ContentsList" />
   </ul>
 </xsl:template>

 <xsl:template match="*" mode="ContentsList">
   <xsl:apply-templates select="*" mode="ContentsList" />
 </xsl:template>

 <xsl:template match="h3" mode="ContentsList">
   <li>
     <a href="{concat('#', @id)}" title="normalize-space(.)">
       <xsl:value-of select="normalize-space(.)" />
     </a>
   </li>
 </xsl:template>

This creates the <ul> tags, and selects the top of the source document to start the search for <h3> tags. This search is done in ‘ContentsList’ mode, and nothing is copied by default. When it comes across an <h3> it creates a list item that links to an element in the document with the id tag. The text and title of the link are taken from the contents of the header tags.

A More Sophisticated Solution

The problem with the previous example is that all the <h3> tags need to have their id attributes set, which is the kind of tedious task the computer should do for itself. Inserting the attributes can not happen as part of the ‘ContentsList’ mode, as it is only reading elements, and can not edit them. Instead we will change the elements during the main copying routine. A small template is used to create the id, so that it is the same in both places.

 <xsl:template name="getId">
   <xsl:value-of select="normalize-space(@id)" />
   <xsl:if test="not(@id)">
     <xsl:value-of select="translate(normalize-space(.), ' ', '_')" />
   </xsl:if>
 </xsl:template>
 <xsl:template match="h3" mode="ContentsList">
   <li>
     <xsl:variable name="id">
       <xsl:call-template name="getId" />
     </xsl:variable>
     <a href="{concat('#', $id)}" title="normalize-space(.)">
       <xsl:value-of select="normalize-space(.)" />
     </a>
   </li>
 </xsl:template>

 <xsl:template match="h3" mode="BodyCopy">
   <xsl:copy>
     <xsl:attribute name="id">
       <xsl:call-template name="getId" />
     </xsl:attribute> 
     <xsl:apply-templates select="@* | node()" mode="BodyCopy" />
   </xsl:copy>
 </xsl:template>

The XHTML specification does not allow spaces in id names, so the translate() is used to turn them into underscores. If there is already an id specified then that is used.

Conclusion

The template presented is roughly what this site uses, although I have made some improvements. One was to allow some <h3> tags to be excluded from the contents list by adding a list="no" attribute. Another was to allow different a title to be used in the contents than the header text, however I haven’t actually used this on the site.

2007 Update

I no longer use XSL to generate pages for this site, Ruby on Rails handles everything instead. This has meant the loss of the contents boxes, as I haven’t got around to replacing them. I guess a solution would be to add an after_filter to the Posts controller that used regular expressions to search for <h3> tags, add in an id and save them to an array, before creating the contents box.

New Website

spam@matthewwest.co.uk(Matthew West) — Sun, 15 Apr 2007 19:46:26 GMT

This website used to be a mix of PHP scripts and XHTML files generated by some big, complicated XSL documents, Java programs and Python scripts, all co-ordinated by an Ant script. In short it was a mess. I’ve replaced the whole lot with a Ruby on Rails application backed by a Postgresql database. All pages are generated dynamically from the database. By keeping everything in the database I hope to make backing up a lot simpler.

The ‘static’ pages, such as the index and the site info pages are created using Comatose while the blog, photos and moving light pages are home grown. The site relies on a number of other plugins to get stuff done, mixed with an awful lot of my own code. The blog is home made, after seeing so many examples of how easy it is to make a blog using RoR on the Web I thought I’d try to do it myself. IIt turns out that it’s not quite so straightforward in real life. I may yet switch over to Mephisto, or something similer. I still prefer to host my own photos etc, rather than putting them on Flickr or suchlike. I have a lot more control over how they are laid out and displayed.

The site is now hosted by Planet Argon using Mongrel and Nginx after the mysterious disappearance of my old hosting company.

There is still stuff missing from the site which I hope to get sorted at some point. As the site is now completely different I can’t just copy and paste pages across. The old computing pages have been reinvented as blog entries, which is why this blog has posts from 2002. The ‘posted at’ dates for those come from the CVS repository for the old site, so I think they’re fairly accurate.

I hope to add some more posts soon about how I solved some specific problems on this site.

Patching the Pearl Expert

spam@matthewwest.co.uk(Matthew West) — Sun, 15 Apr 2007 19:18:21 GMT

I thought I’d put this here so I don’t forget. When you’re patching fixtures on the Avolites Pearl Expert you’ve got to pick a manufacturer, then a fixture. However there’s around 200 manufacturers, and the screen only displays 5 at a time. The trick is to check the number in the corner of the box by each manufacturers name. If you type that number in it will take you to the right screen, saving a lot of button pushing. It doesn’t take you directly to the fixtures because new manufacturers are springing up all the time, so the numbers will change.

The same trick works when choosing fixtures as well.

Link Checker

spam@matthewwest.co.uk(Matthew West) — Fri, 13 Apr 2007 22:03:05 GMT

LinkChecker is a program that checks web page links to make sure that they work. When writing web pages it is easy to make a small typing error that results in a link that doesn’t work. Checking all the links on a web site is time consuming, and it is hard to be sure that they have all been checked. This program checks each link on each page one by one, to make sure that they all work.

Usage

The program can be run from the command line like this:

java -jar /path/to/LinkChecker.jar http://www.mysite.com/index.html -d2000

This will load the index page of www.mysite.com and will check that every link works. Each page that it finds a link to that is also on he same server will be checked in turn. Thus the whole site should eventually be checked, as long as there are links between all the pages. The -d option specifies a delay time in milliseconds. -d2000 specifies a delay of 2 seconds between each page access. This is avoid overloading the server. Each valid address is cached, so that it only needs to be looked up once. If the computer is hosting a copy of a website, and is not connected to the Internet then the -l will cause it to only check local addresses.

The program can only check web pages that are well-formed, which means that they comply with the w3c XML specification. This probably means that it is limited to XHTML web pages. The DTD’s for XHTML are included in the .jar file. If the web pages use different DTD’s then the program will only work if the computer is connected to the Internet.

The program can also be called directly from an Ant build script. First of all the task must be defined:

<taskdef name="checklinks" 
           classname="uk.co.matthewwest.LinkChecker.LinkCheckerTask" 
       classpath="/path/to/LinkChecker.jar" />

Then the task can be called like an other Ant task:

<checklinks href="http://www.mysite.com/index.html" 
            delay="150" local="no" />

Version 0.2

Version 0.2 corrects a couple of problems caused by upgrading of other parts. Apache now gives longer content headers which include the charset while version 0.1 was looking for just “text/html”. Modern versions of Java include an XML parser which gives a SAX warning seemingly every time it comes accross an entity, so version 0.2 suppresses warnings unless ‘debug’ is set to true.

Libraries

Version 0.1 of the program is supplied with Xerces, an XML parser developed by the Apache Foundation. Version 0.2 assumes a more modern version of Java, which comes with an XML library built in. Ant is used to build the project. There are also some DTD’s included which were downloaded from the w3c website.

Download

The program is available for download as a zip file , or as a tar file . My code is released under the terms of the GPL.

How It Works

Each page is parsed by a SAX parser. Every time the parser encounters a link(<a>, <link>, <img>, <form>) it calls checkUrl(). This checks a HashSet of previously validated addresses, and if the URL is not among them it attempts to connect to a server to retrieve it. If it can then the URL is added to the HashSet. If the URL is on the same server as the first page and hasn’t been checked it is added to a LinkedList of pages pending checking. If it cannot retrieve the page then it prints a message. It then moves on to the next page in the list.

Photo Album

spam@matthewwest.co.uk(Matthew West) — Fri, 13 Apr 2007 21:57:10 GMT

Album is a program that creates an HTML photo album. All that is needed is an XML file that describes the layout of the album and provides captions etc, an XSL file describing the layout of the pages and the images themselves. The images must be in Jpeg format, which most photo CD’s seem to have. The program automatically scales them so that their long edges are the same length. It is assumed that they are already the right way up(some photo CD’s don’t do this). The program takes all these and spits out a directory full of HTML pages and image files. These can be uploaded straight onto a website.

Libraries

The program is supplied with Xerces, an XML parser and Xalan, an XSLT processor. The program accesses them through a standardised JAXP interface, so they can probably be replaced with other JAXP compliant libraries. Both of these programs were developed by the Apache Software Foundation. Another program from Apache, Ant is used to build the project.

Download

The program is available for download as a .zip file, or a .tar.gz file. My code is released under the terms of the GPL, Xalan and Xerces are covered by the Apache Licence. There is a sample Photo Album included. This is still very much a work in progress, there is no documentation, few error messages, and some fairly bizarre ‘features’. One such feature is that it pauses between compressing each image. This is because my PC has a propensity for overheating…

Improvements

I can only really see this program being useful for people who are already creating static pages using XSL. Most people seem to be moving toward dynamic pages that apply style sheets ‘on the fly’, so this program is probably already out of date. Each run of the program takes quite a long time. It only creates the image files once, and doesn’t overwrite them, however it creates all the HTML files every time. A better way might be to have a ‘build’ directory which stores all the image files, and a list of creation dates and names, and all the XML files prior to their conversion to XML. This would make it less painful to play with different styles and layouts.

I think overall the best solution would have been to make an interactive program with a GUI. However it would have a lot longer to write. There are commercial websites that allow people to upload their photos, however I’m not sure that they would give as much flexibility as this solution, especially in terms of the final layout. With so much ‘free’ web space available I think there may be a market for an interactive program.

Updated (April 2007)

I no longer use this program, instead I’ve gone for a database backed dynamic site, created using Ruby on Rails. It gives me more flexibility then the likes of Flickr, but at the cost of a lot more effort.

XML to XHTML transformation

spam@matthewwest.co.uk(Matthew West) — Fri, 13 Apr 2007 21:31:55 GMT

I created this XSL document for my old website to display various XML and XSL files that I had created. It effectively adds markup to the document so that the various parts appear in different styles, governed by an external stylesheet. I have stuck to just changing the colours. The layout of the document is roughly preserved. The <?xml ?> line at the beginning is lost, as is the DOCTYPE declaration. Also lost are any text nodes outside the root element. These are added in by the stylesheet. The XSL1 specification does not allow for the creation of ‘identity’ templates, as all entites are resolved by the XML processor before they reach the XSL template.

How It Works

The initial template matches the document node. It first looks for comments, using the prolog mode comment template, which adds a newline after every comment. Thus any comments at the bottom of the source will appear at the top. It then selects either the root element, or any processing instructions.

The attributes are dealt with by the match="@*" template and comments are dealt with by the match="comment()". The match="text()" sorts out all the text, and displays it all, including whitespace to ensure that the document is laid out as it is in the source.

The XSL document seems to manage OK with my documents, which are all laid out in a similar style, however I don’t think it could cope with all documents. The version used to create the old website differed only in that it can be called from other XSL sheets so that I can put a line into my HTML source such as <xml2xhtml root="yes" href="cv2pdf.xsl" /> and the code will be inserted.

The XSL File

This is the file, having been processed by the Syntax Ruby Gem. I don’t use XSL on this website at all anymore. You can Download it.

<?xml version="1.0" encoding="iso-8859-1"?>

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
                xmlns:xalan="http://xml.apache.org/xslt"
        xmlns="http://www.w3.org/1999/xhtml"
                version="1.0">
 <xsl:output omit-xml-declaration="no"
             method="xml"
             doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
             doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
         xalan:indent-amount="1"
         indent="no"
             encoding="iso-8859-1" />
 <xsl:template match="/">
  <html>
   <head>
    <link rel="stylesheet" href="convert.css" />
   </head> 
   <body>
    <pre>
     <xsl:apply-templates select="comment()" mode="prolog" />
     <xsl:apply-templates select="* | processing-instruction()" />
    </pre> 
   </body>
  </html> 
 </xsl:template>

 <xsl:template match="*">
  <xsl:text><</xsl:text>
  <xsl:call-template name="showName">
   <xsl:with-param name="name" select="name()" />
  </xsl:call-template> 
  <xsl:apply-templates select="@*" />
  <xsl:choose>
   <xsl:when test="node()">
    <xsl:text>></xsl:text>
    <xsl:apply-templates />
    <xsl:text><</xsl:text> 
    <xsl:text>/</xsl:text>
    <xsl:call-template name="showName">
     <xsl:with-param name="name" select="name()" />
    </xsl:call-template> 
   </xsl:when>
   <xsl:otherwise> 
    <xsl:text>/</xsl:text>
   </xsl:otherwise>
  </xsl:choose> 
  <xsl:text>></xsl:text>
 </xsl:template>

 <xsl:template name="showName">
  <xsl:param name="name" />
  <xsl:choose>
   <xsl:when test="substring-before($name, ':')">
    <span class="namespace">
     <xsl:value-of select="substring-before($name, ':')" />
    </span>
    <xsl:text>:</xsl:text>
    <span class="element">
     <xsl:value-of select="substring-after($name, ':')" />
    </span>
   </xsl:when>
   <xsl:otherwise>
    <span class="element">
     <xsl:value-of select="$name" />
    </span>
   </xsl:otherwise>
  </xsl:choose>
 </xsl:template>       

 <xsl:template match="processing-instruction()">
  <span class="process">
   <xsl:text><?</xsl:text>
   <xsl:value-of select="name()" />
  </span> 
  <xsl:text> </xsl:text>
  <span class="text"> 
   <xsl:value-of select="." />
  </span> 
  <xsl:text>?></xsl:text>
 </xsl:template>

 <xsl:template match="@*">
  <xsl:text> </xsl:text>
  <span class="attribute">
   <xsl:value-of select="name()" />
   <xsl:text>=</xsl:text>
  </span>
  <span class="text"> 
   <xsl:text>"</xsl:text>
   <xsl:value-of select="." />
   <xsl:text>"</xsl:text>
  </span> 
 </xsl:template>

 <xsl:template match="text()">
  <span class="text"> 
   <xsl:value-of select="." />
  </span> 
 </xsl:template>

 <xsl:template match="comment()">
  <span class="comment">
   <xsl:text><!--</xsl:text>
   <xsl:value-of select="." />
   <xsl:text>--></xsl:text>
  </span>
 </xsl:template>

 <xsl:template match="comment()" mode="prolog">
  <span class="comment">
   <xsl:text><!--</xsl:text>
   <xsl:value-of select="." />
   <xsl:text>--></xsl:text>
  </span><xsl:text>
</xsl:text>
 </xsl:template>

</xsl:stylesheet>