<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet href="/pool/xslt_ht.xslt" type="application/xml"?>
<xsl:stylesheet
  xmlns:xsl = "http://www.w3.org/1999/XSL/Transform"
  xmlns:is = "http://herbaer.de/xmlns/20080705/imgshow"
  xmlns:ht = "http://www.w3.org/1999/xhtml"
  xmlns:d = "http://herbaer.de/xmlns/20051201/doc"
  xmlns = "http://www.w3.org/1999/xhtml"
  exclude-result-prefixes = "d ht is"
  version = "1.0"
>
<d:info xmlns="http://herbaer.de/xmlns/20051201/doc">
  <title>desktop_mkhlp.xslt</title>
  <subtitle>Hilfe zur Dektop-Darstellung einer Bildergeschichte vorbereiten</subtitle>
  <date>2015-07-14</date>
  <author>
    <personname>
      <firstname>Herbert</firstname>
      <surname>Schiemann</surname>
    </personname>
    <email>h.schiemann@herbaer.de</email>
  </author>
</d:info>

<d:section xmlns="http://herbaer.de/xmlns/20051201/doc" role="stylesheet">
<para>
Ohne Bilder keine Bildergeschichte.
Wie sollen die nötigen Bilder mit der Hilfe verknüpft werden?
Die Hilfe-Vorlage <filename>desktop_help.xhtml.de</filename> enthält
<tag class="element">span</tag>-Elemente mit dem Attribut
<tag class="attribute">class</tag> = <tag class="attvalue">imglink</tag>,
genau wie die XHTML-Darstellung einer Bildergeschichte,
aber ohne Verweis auf ein Bild.
Diese Transformation übernimmt die Verweise aus einer wirklichen "Bildergeschichte".
</para>
</d:section>

<d:para>Vorlagen für einfachen Text</d:para>
<xsl:include href="/pool/txt.xslt"/>

<d:para>Vorlagen für Listen</d:para>
<xsl:include href="/pool/list.xslt"/>

<d:para>
Relative URL der "Bildergeschichte".
Die Verweise auf Bilder werden in die Hilfe übernommen.
</d:para>
<xsl:param name="p_fnstory"/>

<d:para>Wurzel-Element dieses Stylesheets</d:para>
<xsl:variable name="g_stylesheetroot" select="document('')/xsl:stylesheet"/>

<d:para>Wurzel-Element der Bildergeschichte</d:para>
<xsl:variable name="g_storyroot" select="document($p_fnstory)/is:document"/>

<d:para>Die Abschnitte der Bildergeschichte</d:para>
<xsl:variable name="g_sections" select="$g_storyroot/is:section"/>

<d:section xmlns="http://herbaer.de/xmlns/20051201/doc" role="stylesheet">
<section>
<title>Zuordnung von Bildern zu Bildverweisen</title>
<para>
(i) Die Abschnitte der Hilfe-Vorlage und der Bildergeschichte werden nach der Anzahl
der enthaltenen Bildverweise absteigend geordnet und dann paarweise zugeordnet.
</para>
<para>
Nach der Zuordnung von Abschnitten kann es sein, dass Bildverweisen in der Hilfe-Vorlage
kein Bild aus dem zugeordneten Abschnitt der Bildergeschichte zugeordnet ist.
<literal>NH</literal> sei die Anzahl der "freien" Bildverweise in der Hilfe-Vorlage.
Die freien Bildverweise bleiben in der "Dokument-Reihenfolge".
</para>
<para>
(ii) Zunächst wird versucht,
die freien Bildverweise mit freien Bildern aus Textabschnitten
der Bildergeschichte zu belegen (Anzahl <literal>NSTF</literal>).
Wenn <literal>NH</literal> &lt;= <literal>NSTF</literal>, ist die Zuordnung klar.
</para>
<para>
(iii) Andernfalls werden freie Bilder aus Bildlisten-Abschnitten der Bildergeschichte
hinzugenommen, aber aus jedem Abschnitt
nicht mehr als die maximale Zahl freie Bilder in einem Textabschnitt.
Es seien <literal>NSMF</literal> die maximale Zahl freier Bilder in einem Textabschnitt
und <literal>NSKF</literal>
die Anzahl der hinzukommenden freien Bilder aus Bildlisten-Abschnitten.
Wenn <literal>NH</literal> &lt;= <literal>NSTF</literal> + <literal>NSKF</literal>,
dann können alle Bildverweise zugeordnet werden.
Die zuzuordnenden Bilder werden nach der Position unter den freien Bildern des Abschnitts
und der Position des Abschnitts sortiert.
</para>
<para>
(iv) Andernfalls werden alle Bilder der Textabschnitte hinzugenommen.
Es sei <literal>NST</literal> ihre Anzahl.
Wenn
<literal>NH</literal> &lt;= <literal>NSTF</literal> + <literal>NSKF</literal>
+ <literal>NST</literal>,
erfolgt die Zuordnung:
die Bilder der Textabschnitte werden nach der Position im Abschnitt und der Position
des Abschnitts sortiert und an die Liste der freien Bilder angehängt.
</para>
<para>
(v) Andernfalls werden alle Bilder der Bildergeschichte hinzugenommen,
falls nötig, mehrfach.
Ihre Anzahl sei <literal>NS</literal>.
Sie werden nach der Position der Bilder im Abschnitt und der Position des Abschnitts
sortiert.
<literal>MI</literal> sei die kleinste nicht negative Zahl derart, dass
<literal>NH</literal> &lt;= <literal>NSTF</literal> + <literal>NSKF</literal>
+ <literal>MI</literal> * <literal>NS</literal>.
</para>
</section>

<section>
<title>Listen</title>
<para>
Hier werden mehrere Listen verwendet.
Die Trennzeichenfolge ist ein einfaches Leerzeichen.
Die Listeneinträge haben die Form
<literal>([<replaceable>key</replaceable>]<replaceable>value</replaceable>)+[</literal>.
Die verwendeten Schlüssel (<replaceable>key</replaceable>) sind:
</para>
<variablelist>
  <varlistentry>
    <term><literal>SS</literal></term>
    <listitem>
      <para>
        Position eines Abschnitts der "Bildergeschichte",
        beginnend mit 1.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>SN</literal></term>
    <listitem>
      <para>
        Anzahl der Bildverweise in einem Abschnitt der Bildergeschichte.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>SB</literal></term>
    <listitem>
      <para>
        Anzahl der Bildverweise vor einem Abschnitt der Bildergeschichte.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>ST</literal></term>
    <listitem>
      <para>
        Art eines Abschnitts der Bildergeschichte:
        <literal>0</literal> bedeutet, dass der Abschnitt Text enthält,
        <literal>1</literal> kennzeichnet reine Bilder-Listen.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>SI</literal></term>
    <listitem>
      <para>
        Position eines Bildes innerhalb des Abschnitts der Bildergeschichte,
        beginnend mit 1.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>IK</literal></term>
    <listitem>
      <para>
        Kennung eines Bildes: <tag class="attribute">is:jpg/@src</tag>.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>HS</literal></term>
    <listitem>
      <para>
        Position eines Abschnitts (<literal>ht:body/ht:div</literal>) der Hilfe-Vorlage,
        beginnend mit 1.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>HN</literal></term>
    <listitem>
      <para>
        Anzahl der Bildverweise (<literal>ht:span[@class = 'imglink']</literal>)
        in einem Abschnitt der Hilfe-Vorlage.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>HB</literal></term>
    <listitem>
      <para>
        Anzahl der Bildverweise (<literal>ht:span[@class = 'imglink']</literal>)
        vor einem Abschnitt der Hilfe-Vorlage.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>HL</literal></term>
    <listitem>
      <para>
        Position eines Bildverweises (<literal>ht:span[@class = 'imglink']</literal>)
        in der Hilfe-Vorlage, beginnend mit 1.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><literal>Z</literal></term>
    <listitem>
      <para>
        Anzahl der durch die Abschnitt-Zuordnung zugeordneten Bildverweise
        in einem Abschnitt: <literal>min (HN, SN)</literal>
      </para>
    </listitem>
  </varlistentry>
</variablelist>
<para>
Die Listen sind:
</para>
<variablelist>
  <varlistentry>
    <term><varname>g_ls_help</varname></term>
    <listitem>
      <para>
        Die Abschnitte der Hilfe-Vorlage
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><varname>g_ls_story</varname></term>
    <listitem>
      <para>
        Die Abschnitte der Bildergeschichte
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><varname>g_ls_zipped</varname></term>
    <listitem>
      <para>
        Die zusammengeführte Liste der Abschnitte
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><varname>g_li_help</varname></term>
    <listitem>
      <para>
        Die Bildverweise in der Hilfe-Vorlage
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><varname>g_li_base</varname></term>
    <listitem>
      <para>
        Die Bilder der Bildergeschichte,
        die gemäß den Regeln (i) bis (iii) einem Bildverweis zugeordnet sind
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><varname>g_li_fill</varname></term>
    <listitem>
      <para>
        Die Bilder der Bildergeschichte,
        die gemäß den Regeln (iv) und (v) einem Bildverweis zugeordnet werden
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><varname>g_li_match</varname></term>
    <listitem>
      <para>
        Die Liste <varname>g_li_fill</varname> wird
        evtl. mehrfach (<literal>MI</literal> mal)
        an die Liste <varname>g_li_base</varname> angehängt.
        Die zusammengesetzte Liste wird mit der Liste <varname>g_li_help</varname>
        elementweise ("reißverschlussartig") zusammengefügt.
        Die resultierende Liste <varname>g_li_match</varname>
        ordnet Bildverweisen in der Hilfe-Vorlage,
        bezeichnet durch <literal>HL</literal>,
        die Kennung <literal>IK</literal> eines Bildes zu.
      </para>
    </listitem>
  </varlistentry>
</variablelist>
</section>

</d:section>

<d:para>
Diese Liste enthält einen Eintrag zu jedem Abschnitt der Bildergeschichte,
der einen Bildverweis enthält.
Die Schlüssel in den Listeneinträgen sind
<literal>SS</literal>, <literal>SN</literal>, <literal>SB</literal> und
<literal>ST</literal>.
Die Einträge sind nach <literal>ST</literal> und <literal>SN</literal> (fallend)
sortiert.
</d:para>
<xsl:variable name="g_ls_story">
  <xsl:for-each select="$g_storyroot/is:section [.//is:jpg]">
    <xsl:sort select="string-length (normalize-space(is:p)) = 0"/>
    <xsl:sort order="descending" data-type="number" select="count (.//is:jpg)"/>
    <xsl:variable name="ss" select="count (preceding::is:section) + 1"/>
    <xsl:variable name="sn" select="count (.//is:jpg)"/>
    <xsl:variable name="sb" select="count (preceding::is:jpg)"/>
    <xsl:variable name="st">
      <xsl:choose>
        <xsl:when test="string-length (normalize-space(is:p)) &gt; 0">0</xsl:when>
        <xsl:otherwise>1</xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <xsl:if test="position () &gt; 1"><xsl:text> </xsl:text></xsl:if>
    <xsl:value-of select="concat ('[SS]', $ss, '[SN]', $sn, '[SB]', $sb, '[ST]', $st, '[')"
    />
  </xsl:for-each>
</xsl:variable>

<d:para>
Diese Liste enthält zu fast jedem Abschnitt der Hilfe-Vorlage einen Eintrag
mit den Schlüsseln
<literal>HS</literal>, <literal>HN</literal> und <literal>HB</literal>.
Die Liste ist nach <literal>HN</literal> absteigend sortiert.
Ausgenommen ist nur der erste Abschnitt, der keinen Bildverweis enthält.
</d:para>
<xsl:variable name="g_ls_help">
  <xsl:for-each
    select = "
      /ht:html/ht:body/ht:div [
      .//ht:span [@class = 'imglink']
      or preceding-sibling::ht:div [not (.//ht:span [@class = 'imglink'])] ]
    "
  >
    <xsl:sort order="descending" data-type="number" select="count (.//ht:span [@class = 'imglink'])"
    />
    <xsl:variable name="hs" select="count (preceding-sibling::ht:div) + 1"/>
    <xsl:variable name="hn" select="count (.//ht:span [@class = 'imglink'])"/>
    <xsl:variable name="hb" select="count (preceding::ht:span [@class = 'imglink'])"/>
    <xsl:if test="position () &gt; 1"><xsl:text> </xsl:text></xsl:if>
    <xsl:value-of select="concat ('[HS]', $hs, '[HN]', $hn, '[HB]', $hb, '[')"/>
  </xsl:for-each>
</xsl:variable>

<d:para>
Die zusammengeführte Liste der Abschnitte
</d:para>
<xsl:variable name="g_ls_zipped">
  <xsl:call-template name="list.zip">
    <xsl:with-param name="first" select="$g_ls_story"/>
    <xsl:with-param name="second" select="$g_ls_help"/>
    <xsl:with-param name="zipper" select="$g_stylesheetroot/xsl:template [@name = 'zip_sections']"
    />
  </xsl:call-template>
</xsl:variable>

<d:para>
Dieser "Zipper" führt Abschnitte der Bildergeschichte und der Hilfe-Vorlage zusammen.
</d:para>
<xsl:template
  name = "zip_sections"
  mode = "list.apply"
  match = "xsl:template [@name = 'zip_sections' and @mode = 'list.apply' and @match]"
>
  <!-- der Eintrag der ersten Liste -->
  <xsl:param name="first"/>
  <!-- der Eintrag der zweiten Liste an derselben Position -->
  <xsl:param name="second"/>
  <xsl:if test="string-length ($first) &gt; 0 and string-length ($second) &gt; 0">
    <xsl:value-of select="concat ($first, substring ($second, 2))"/>
  </xsl:if>
</xsl:template>

<d:para>Anzahl der "freien" Bildverweise in der Hilfe-Vorlage</d:para>
<xsl:variable name="g_nh">
  <xsl:call-template name="list.accumulate">
    <xsl:with-param name="list" select="$g_ls_help"/>
    <xsl:with-param name="accumulator" select="$g_stylesheetroot/xsl:template [@name = 'accu_nh']"
    />
  </xsl:call-template>
</xsl:variable>

<d:para>
Listen-Akkumulator:
ermittelt aus der Liste der Abschnitte der Hilfe-Vorlage
die Anzahl der freien Bildverweise in der Vorlage.
</d:para>
<xsl:template
  name = "accu_nh"
  mode = "list.apply"
  match = "xsl:template [@name = 'accu_nh' and @mode = 'list.apply' and @match]"
>
  <!-- der aktuelle Listeneintrag -->
  <xsl:param name="item"/>
  <!-- der bisher akkumulierte Wert -->
  <xsl:param name="cur"/>
  <xsl:variable name="start">
    <xsl:choose>
      <xsl:when test="string-length ($cur) = 0">0</xsl:when>
      <xsl:otherwise><xsl:value-of select="$cur"/></xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="hs" select="substring-before (substring-after ($item, '[HS]'), '[')"
  />
  <xsl:variable name="hn" select="substring-before (substring-after ($item, '[HN]'), '[')"
  />
  <xsl:variable name="li">
    <xsl:call-template name="list.entry_by_key">
      <xsl:with-param name="list" select="$g_ls_zipped"/>
      <xsl:with-param name="key" select="concat ('[HS]', $hs, '[')"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="string-length ($li) = 0">
      <xsl:value-of select="$start + $hn"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="sn" select="substring-before (substring-after ($li, '[SN]'), '[')"
      />
      <xsl:choose>
        <xsl:when test="$hn &gt; $sn">
          <xsl:value-of select="$start + $hn - $sn"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="$start"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<d:para>Anzahl der freien Bilder in Textabschnitten der Bildergeschichte</d:para>
<xsl:variable name="g_nstf">
  <xsl:call-template name="list.accumulate">
    <xsl:with-param name="list" select="$g_ls_story"/>
    <xsl:with-param name="accumulator" select="$g_stylesheetroot/xsl:template [@name = 'accu_nstf']"
    />
  </xsl:call-template>
</xsl:variable>

<d:para>
Listen-Akkumulator:
ermittelt aus der Liste der Abschnitte der Bildergeschichte
die Anzahl der freien Bilder in Textabschnitten der Bildergeschichte.
</d:para>
<xsl:template
  name = "accu_nstf"
  mode = "list.apply"
  match = "xsl:template [@name = 'accu_nstf' and @mode = 'list.apply' and @match]"
>
  <!-- der aktuelle Listeneintrag -->
  <xsl:param name="item"/>
  <!-- der bisher akkumulierte Wert -->
  <xsl:param name="cur"/>
  <xsl:variable name="start">
    <xsl:choose>
      <xsl:when test="string-length ($cur) = 0">0</xsl:when>
      <xsl:otherwise><xsl:value-of select="$cur"/></xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="substring-before (substring-after ($item, '[ST]'), '[') = 1">
      <xsl:value-of select="$start"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="ss" select="substring-before (substring-after ($item, '[SS]'), '[')"
      />
      <xsl:variable name="sn" select="substring-before (substring-after ($item, '[SN]'), '[')"
      />
      <xsl:variable name="li">
        <xsl:call-template name="list.entry_by_key">
          <xsl:with-param name="list" select="$g_ls_zipped"/>
          <xsl:with-param name="key" select="concat ('[SS]', $ss, '[')"/>
        </xsl:call-template>
      </xsl:variable>
      <xsl:choose>
        <xsl:when test="string-length ($li) = 0">
          <xsl:value-of select="$start + $sn"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:variable name="hn" select="substring-before (substring-after ($li, '[HN]'), '[')"
          />
          <xsl:choose>
            <xsl:when test="$sn &gt; $hn">
              <xsl:value-of select="$start + $sn - $hn"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:value-of select="$start"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<d:para>
Die maximale Zahl freier Bilder in einem Textabschnitt
</d:para>
<xsl:variable name="g_nsmf">
  <xsl:call-template name="list.accumulate">
    <xsl:with-param name="list" select="$g_ls_story"/>
    <xsl:with-param name="accumulator" select="$g_stylesheetroot/xsl:template [@name = 'accu_nsmf']"
    />
  </xsl:call-template>
</xsl:variable>

<d:para>
Listen-Akkumulator:
ermittelt aus der Liste der Abschnitte der Bildergeschichte
die maximale Anzahl der freien Bilder in einem Textabschnitt der Bildergeschichte.
</d:para>
<xsl:template
  name = "accu_nsmf"
  mode = "list.apply"
  match = "xsl:template [@name = 'accu_nsmf' and @mode = 'list.apply' and @match]"
>
  <!-- der aktuelle Listeneintrag -->
  <xsl:param name="item"/>
  <!-- der bisher akkumulierte Wert -->
  <xsl:param name="cur"/>
  <xsl:variable name="start">
    <xsl:choose>
      <xsl:when test="string-length ($cur) = 0">0</xsl:when>
      <xsl:otherwise><xsl:value-of select="$cur"/></xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="sn" select="substring-before (substring-after ($item, '[SN]'), '[')"
  />
  <xsl:choose>
    <xsl:when test="substring-before (substring-after ($item, '[ST]'), '[') = 1 or $sn &lt;= $start"
    >
      <xsl:value-of select="$start"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="ss" select="substring-before (substring-after ($item, '[SS]'), '[')"
      />
      <xsl:variable name="li">
        <xsl:call-template name="list.entry_by_key">
          <xsl:with-param name="list" select="$g_ls_zipped"/>
          <xsl:with-param name="key" select="concat ('[SS]', $ss, '[')"/>
        </xsl:call-template>
      </xsl:variable>
      <xsl:choose>
        <xsl:when test="string-length ($li) = 0">
          <xsl:value-of select="$sn"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:variable name="hn" select="substring-before (substring-after ($li, '[HN]'), '[')"
          />
          <xsl:choose>
            <xsl:when test="$sn &gt; $hn + $start">
              <xsl:value-of select="$sn - $hn"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:value-of select="$start"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<d:para>
Anzahl der hinzukommenden freien Bilder in Bildlisten-Abschnitten der Bildergeschichte
</d:para>
<xsl:variable name="g_nskf">
  <xsl:call-template name="list.accumulate">
    <xsl:with-param name="list" select="$g_ls_story"/>
    <xsl:with-param name="accumulator" select="$g_stylesheetroot/xsl:template [@name = 'accu_nskf']"
    />
  </xsl:call-template>
</xsl:variable>

<d:para>
Listen-Akkumulator:
ermittelt aus der Liste der Abschnitte der Bildergeschichte
die Anzahl der hinzukommenden freien Bilder in Bildlisten-Abschnitten
</d:para>
<xsl:template
  name = "accu_nskf"
  mode = "list.apply"
  match = "xsl:template [@name = 'accu_nskf' and @mode = 'list.apply' and @match]"
>
  <!-- der aktuelle Listeneintrag -->
  <xsl:param name="item"/>
  <!-- der bisher akkumulierte Wert -->
  <xsl:param name="cur"/>
  <xsl:variable name="start">
    <xsl:choose>
      <xsl:when test="string-length ($cur) = 0">0</xsl:when>
      <xsl:otherwise><xsl:value-of select="$cur"/></xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="substring-before (substring-after ($item, '[ST]'), '[') = 0">
      <xsl:value-of select="$start"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="ss" select="substring-before (substring-after ($item, '[SS]'), '[')"
      />
      <xsl:variable name="sn" select="substring-before (substring-after ($item, '[SN]'), '[')"
      />
      <xsl:variable name="li">
        <xsl:call-template name="list.entry_by_key">
          <xsl:with-param name="list" select="$g_ls_zipped"/>
          <xsl:with-param name="key" select="concat ('[SS]', $ss, '[')"/>
        </xsl:call-template>
      </xsl:variable>
      <xsl:variable name="f">
        <xsl:choose>
          <xsl:when test="string-length ($li) = 0">
            <xsl:value-of select="$sn"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:variable name="hn" select="substring-before (substring-after ($li, '[HN]'), '[')"
            />
            <xsl:choose>
              <xsl:when test="$sn &gt; $hn">
                <xsl:value-of select="$sn - $hn"/>
              </xsl:when>
              <xsl:otherwise>
                <xsl:value-of select="0"/>
              </xsl:otherwise>
            </xsl:choose>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:variable>
      <xsl:choose>
        <xsl:when test="$f &lt; $g_nsmf">
          <xsl:value-of select="$start + $f"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="$start + $g_nsmf"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<d:para>Anzahl aller Bilder in Textabschnitten der Bildergeschichte</d:para>
<xsl:variable name="g_nst">
  <xsl:call-template name="list.accumulate">
    <xsl:with-param name="list" select="$g_ls_story"/>
    <xsl:with-param name="accumulator" select="$g_stylesheetroot/xsl:template [@name = 'accu_ns']"
    />
    <xsl:with-param name="param" select="0"/><!-- nur Bilder in Textabschnitten -->
  </xsl:call-template>
</xsl:variable>

<d:para>Anzahl aller Bilder der Bildergeschichte, falls nötig.</d:para>
<xsl:variable name="g_ns">
  <xsl:if test="$g_nh &gt; $g_nstf + $g_nskf">
    <xsl:call-template name="list.accumulate">
      <xsl:with-param name="list" select="$g_ls_story"/>
      <xsl:with-param name="accumulator" select="$g_stylesheetroot/xsl:template [@name = 'accu_ns']"
      />
    </xsl:call-template>
  </xsl:if>
</xsl:variable>

<d:para>
Listen-Akkumulator:
ermittelt aus der Liste der Abschnitte der Bildergeschichte
die Anzahl der Bilder,
abhängig von <d:parameter>param</d:parameter> nur in Textabschnitten
oder nur in Bilderlisten-Abschnitten oder in allen Abschnitten.
</d:para>
<xsl:template
  name = "accu_ns"
  mode = "list.apply"
  match = "xsl:template [@name = 'accu_ns' and @mode = 'list.apply' and @match]"
>
  <!-- der aktuelle Listeneintrag -->
  <xsl:param name="item"/>
  <!-- die bisher gezählten Bilder -->
  <xsl:param name="cur"/>
  <!--
  schränkt die Auswahl der Bilder ein:
  0 nur Bilder aus Textabschnitten,
  1 nur Bilder aus Bilderlisten-Abschnitten,
  2 alle Bilder
  -->
  <xsl:param name="param" select="2"/>
  <xsl:variable name="start">
    <xsl:choose>
      <xsl:when test="string-length ($cur) = 0">0</xsl:when>
      <xsl:otherwise><xsl:value-of select="$cur"/></xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <xsl:when
      test = "
        $param &lt; 2 and substring-before (substring-after ($item,
        '[ST]'),
        '[') != $param
      "
    >
      <xsl:value-of select="$start"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="sn" select="substring-before (substring-after ($item, '[SN]'), '[')"
      />
      <xsl:value-of select="$start + $sn"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<d:para>
Liste aller Bildverweise in der Hilfevorlage.
Jeder Listeneintrag enthält die Schlüssel
<d:literal>HS</d:literal>, <d:literal>HB</d:literal>, <d:literal>HL</d:literal>
und <d:literal>Z</d:literal>.
Die Liste ist sortiert:
Am Anfang stehen Bildverweise, denen über den Abschnitt ein Bild zugeordnet ist,
dann folgen die "freien" Bildverweise sortiert nach <d:literal>HL</d:literal>
</d:para>
<xsl:variable name="g_li_help">
  <xsl:call-template name="list.sort">
    <xsl:with-param name="list">
      <xsl:for-each select="//ht:body/ht:div [.//ht:span [@class = 'imglink']]">
        <xsl:variable name="hs" select="count (preceding-sibling::ht:div) + 1"/>
        <xsl:variable name="hb" select="count (preceding::ht:span [@class = 'imglink'])"/>
        <xsl:variable name="li">
          <xsl:call-template name="list.entry_by_key">
            <xsl:with-param name="list" select="$g_ls_zipped"/>
            <xsl:with-param name="key" select="concat ('[HS]', $hs, '[')"/>
          </xsl:call-template>
        </xsl:variable>
        <xsl:variable name="z">
          <xsl:choose>
            <xsl:when test="string-length ($li) = 0">0</xsl:when>
            <xsl:otherwise>
              <xsl:variable name="hn" select="substring-before (substring-after ($li, '[HN]'), '[')"
              />
              <xsl:variable name="sn" select="substring-before (substring-after ($li, '[SN]'), '[')"
              />
              <xsl:choose>
                <xsl:when test="$hn &lt; $sn">
                  <xsl:value-of select="$hn"/>
                </xsl:when>
                <xsl:otherwise>
                  <xsl:value-of select="$sn"/>
                </xsl:otherwise>
              </xsl:choose>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:variable>
        <xsl:if test="$hs &gt; 1">
          <xsl:value-of select="' '"/>
        </xsl:if>
        <xsl:for-each select=".//ht:span [@class = 'imglink']">
          <xsl:if test="position() &gt; 1">
            <xsl:value-of select="' '"/>
          </xsl:if>
          <xsl:value-of select="concat ('[HS]', $hs, '[HL]', $hb + position(), '[Z]', $z, '[HB]', $hb, '[')"
          />
        </xsl:for-each>
      </xsl:for-each>
    </xsl:with-param><!-- list -->
    <xsl:with-param name="sorter" select="$g_stylesheetroot/xsl:template [@name = 'compare_li_help']"
    />
  </xsl:call-template><!-- list.sort -->
</xsl:variable>

<d:para>
Vergleicher für die Sortierung der Liste <d:varname>g_li_help</d:varname>:
Die durch die Abschnittszuordung zugeordneten Bildverweise
stehen vor den "freien" Bildverweisen,
nachrangig sind die Verweise nach der Position in der Hilfe-Vorlage geordnet.
</d:para>
<xsl:template
  name = "compare_li_help"
  mode = "list.apply"
  match = "xsl:template [@name = 'compare_li_help' and @mode = 'list.apply' and @match]"
>
  <!-- der erste Wert zum Vergleich -->
  <xsl:param name="a"/>
  <!-- der zweite Wert zum Vergleich -->
  <xsl:param name="b"/>
  <xsl:variable name="ahb" select="substring-before(substring-after($a, '[HB]'), '[')"/>
  <xsl:variable name="ahl" select="substring-before(substring-after($a, '[HL]'), '[')"/>
  <xsl:variable name="az" select="substring-before(substring-after($a, '[Z]'),  '[')"/>
  <xsl:variable name="bhb" select="substring-before(substring-after($b, '[HB]'), '[')"/>
  <xsl:variable name="bhl" select="substring-before(substring-after($b, '[HL]'), '[')"/>
  <xsl:variable name="bz" select="substring-before(substring-after($b, '[Z]'),  '[')"/>
  <xsl:variable name="ax">
    <xsl:choose>
      <xsl:when test="$ahb + $az &lt; $ahl">1</xsl:when>
      <xsl:otherwise>0</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="bx">
    <xsl:choose>
      <xsl:when test="$bhb + $bz &lt; $bhl">1</xsl:when>
      <xsl:otherwise>0</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$ax &lt; $bx">1</xsl:when>
    <xsl:when test="$ax &gt; $bx">-1</xsl:when>
    <xsl:when test="$ahl &lt; $bhl">1</xsl:when>
    <xsl:when test="$ahl &gt; $bhl">-1</xsl:when>
    <xsl:otherwise>0</xsl:otherwise>
  </xsl:choose>
</xsl:template><!-- compare_li_help -->

<d:para>
Liste der Bilder der Bildergeschichte
mit den Schlüsseln <literal>SS</literal>, <literal>ST</literal>, <literal>SI</literal>,
<literal>HS</literal>, <literal>Z</literal> und <literal>IK</literal>
</d:para>
<xsl:variable name="g_li_story">
  <xsl:for-each select="$g_storyroot/is:section [.//is:jpg]">
    <xsl:variable name="ss" select="count (preceding-sibling::is:section) + 1"/>
    <xsl:variable name="st">
      <xsl:choose>
        <xsl:when test="string-length (normalize-space(is:p)) &gt; 0">0</xsl:when>
        <xsl:otherwise>1</xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <xsl:variable name="li">
      <xsl:call-template name="list.entry_by_key">
        <xsl:with-param name="list" select="$g_ls_zipped"/>
        <xsl:with-param name="key" select="concat ('[SS]', $ss, '[')"/>
      </xsl:call-template>
    </xsl:variable>
    <xsl:variable name="hn" select="substring-before(substring-after($li, '[HN]'), '[')"/>
    <xsl:variable name="hs" select="substring-before(substring-after($li, '[HS]'), '[')"/>
    <xsl:variable name="z">
      <xsl:choose>
        <xsl:when test="string-length ($li) = 0">0</xsl:when>
        <xsl:otherwise>
          <xsl:variable name="sn" select="substring-before (substring-after ($li, '[SN]'), '[')"
          />
          <xsl:choose>
            <xsl:when test="$hn &lt; $sn">
              <xsl:value-of select="$hn"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:value-of select="$sn"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <xsl:if test="position() &gt; 1">
      <xsl:value-of select="' '"/>
    </xsl:if>
    <xsl:for-each select=".//is:jpg">
      <xsl:variable name="si" select="position ()"/>
      <xsl:if test="$si &gt; 1">
        <xsl:value-of select="' '"/>
      </xsl:if>
      <xsl:value-of
        select = "
          concat (
          '[SS]', $ss, '[ST]', $st, '[SI]', $si, '[HS]', $hs, '[Z]', $z, '[IK]', @src, '['
          )
        "
      />
    </xsl:for-each>
  </xsl:for-each>
</xsl:variable><!-- g_li_story -->

<d:para>
Die "Basisliste" der Bilder der Bildergeschichte:
Bilder, die gemäß den Regeln (i) bis (iii) Verweisen zugeordnet sind.
</d:para>
<xsl:variable name="g_li_base">
  <xsl:call-template name="list.map_sort">
    <xsl:with-param name="list" select="$g_li_story"/>
    <xsl:with-param name="mapper" select="$g_stylesheetroot/xsl:template [@name = 'select_base']"
    />
    <xsl:with-param name="sorter" select="$g_stylesheetroot/xsl:template [@name = 'compare_li_base']"
    />
  </xsl:call-template>
</xsl:variable>

<d:para>
Der "Mapper" wählt die Bilder aus,
die gemäß den Regeln (i) bis (iii) zugeordnet sind.
</d:para>
<xsl:template
  name = "select_base"
  mode = "list.apply"
  match = "xsl:template [@name = 'select_base' and @mode = 'list.apply' and @match]"
>
  <!-- der aktuelle Listeneintrag -->
  <xsl:param name="item"/>
  <xsl:variable name="si" select="substring-before(substring-after($item, '[SI]'), '[')"/>
  <xsl:variable name="z" select="substring-before(substring-after($item, '[Z]' ), '[')"/>
  <xsl:variable name="st" select="substring-before(substring-after($item, '[ST]'), '[')"/>
  <xsl:if
    test = "
      $si &lt;= $z
      or ($g_nh &gt; 0 and $st = 0)
      or ($g_nh &gt; $g_nstf and $si &lt;= $z + $g_nsmf)
    "
  >
    <xsl:value-of select="$item"/>
  </xsl:if>
</xsl:template><!-- select_base -->

<d:para>
Vergleicher für die Sortierung der Liste <d:varname>g_li_base</d:varname>:
Die durch die Abschnittszuordung zugeordneten Bilder
stehen vor den "freien" Bildern und sind nach dem Abschnitt der Hilfe-Vorlage
und der Position im Abschnitt der Bildergeschichte sortiert.
Die "freien" Bilder sind vorrangig nach der Position im Abschnitt der Bildergeschichte
und nach der Position des Abschnitts der Bildergeschichte sortiert.
</d:para>
<xsl:template
  name = "compare_li_base"
  mode = "list.apply"
  match = "xsl:template [@name = 'compare_li_base' and @mode = 'list.apply' and @match]"
>
  <!-- der erste Wert zum Vergleich -->
  <xsl:param name="a"/>
  <!-- der zweite Wert zum Vergleich -->
  <xsl:param name="b"/>
  <xsl:variable name="asi" select="substring-before (substring-after ($a, '[SI]'), '[')"/>
  <xsl:variable name="az" select="substring-before (substring-after ($a, '[Z]'),  '[')"/>
  <xsl:variable name="bsi" select="substring-before (substring-after ($b, '[SI]'), '[')"/>
  <xsl:variable name="bz" select="substring-before (substring-after ($b, '[Z]'),  '[')"/>
  <xsl:variable name="ax">
    <xsl:choose>
      <xsl:when test="$asi &lt;= $az">0</xsl:when>
      <xsl:otherwise>1</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="bx">
    <xsl:choose>
      <xsl:when test="$bsi &lt;= $bz">0</xsl:when>
      <xsl:otherwise>1</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$ax &lt; $bx">1</xsl:when>
    <xsl:when test="$ax &gt; $bx">-1</xsl:when>
    <xsl:when test="$ax = 0">
      <xsl:variable name="ahs" select="substring-before (substring-after ($a, '[HS]'), '[')"
      />
      <xsl:variable name="bhs" select="substring-before (substring-after ($b, '[HS]'), '[')"
      />
      <xsl:choose>
        <xsl:when test="$ahs &lt; $bhs">1</xsl:when>
        <xsl:when test="$ahs &gt; $bhs">-1</xsl:when>
        <xsl:when test="$asi &lt; $bsi">1</xsl:when>
        <xsl:when test="$asi &gt; $bsi">-1</xsl:when>
        <xsl:otherwise>0</xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="ass" select="substring-before (substring-after ($a, '[SS]'), '[')"
      />
      <xsl:variable name="bss" select="substring-before (substring-after ($b, '[SS]'), '[')"
      />
      <xsl:choose>
        <xsl:when test="$asi + $bz &lt; $bsi + $az">1</xsl:when>
        <xsl:when test="$asi + $bz &gt; $bsi + $az">-1</xsl:when>
        <xsl:when test="$ass &lt; $bss">1</xsl:when>
        <xsl:when test="$ass &gt; $bss">-1</xsl:when>
        <xsl:otherwise>0</xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template><!-- compare_li_base -->

<d:para>Bilder, die gemäß den Regeln (iv) und (v) zugeordnet werden</d:para>
<xsl:variable name="g_li_fill">
  <xsl:if test="$g_nh &gt; $g_nstf + $g_nskf">
    <xsl:call-template name="list.map_sort">
      <xsl:with-param name="list" select="$g_li_story"/>
      <xsl:with-param name="mapper" select="$g_stylesheetroot/xsl:template [@name = 'map_fill']"
      />
      <xsl:with-param name="sorter" select="$g_stylesheetroot/xsl:template [@name = 'compare_li_fill']"
      />
    </xsl:call-template>
  </xsl:if>
</xsl:variable>

<d:para>
Dieser "Mapper" wählt aus jedem Eintrag die Felder SS, SI und IK aus,
und wählt, falls möglich, nur die Bilder aus Textabschnitten aus.
</d:para>
<xsl:template
  name = "map_fill"
  mode = "list.apply"
  match = "xsl:template [@name = 'map_fill' and @mode = 'list.apply' and @match]"
>
  <!-- der Listeneintrag -->
  <xsl:param name="item"/>
  <xsl:if
    test = "
      $g_nh &gt; $g_nstf + $g_nskf + $g_nst
      or substring-before (substring-after ($item, '[ST]'), '[') = 0
    "
  >
    <xsl:value-of
      select = "
        concat (
        '[SS]', substring-before (substring-after ($item, '[SS]'), '['),
        '[SI]', substring-before (substring-after ($item, '[SI]'), '['),
        '[IK]', substring-before (substring-after ($item, '[IK]'), '['),
        '[' )
      "
    />
  </xsl:if>
</xsl:template><!-- map_fill -->

<d:para>
Vergleicher für die Sortierung der Liste <d:varname>g_li_fill</d:varname>:
Die Bilder werden nach ihrer Position im Abschnitt der Bildergeschichte
und der Position des Abschnitts der Bildergeschichte sortiert.
</d:para>
<xsl:template
  name = "compare_li_fill"
  mode = "list.apply"
  match = "xsl:template [@name = 'compare_li_fill' and @mode = 'list.apply' and @match]"
>
  <!-- der erste Wert zum Vergleich -->
  <xsl:param name="a"/>
  <!-- der zweite Wert zum Vergleich -->
  <xsl:param name="b"/>
  <xsl:variable name="asi" select="substring-before(substring-after($a, '[SI]'), '[')"/>
  <xsl:variable name="ass" select="substring-before(substring-after($a, '[SS]'), '[')"/>
  <xsl:variable name="bsi" select="substring-before(substring-after($b, '[SI]'), '[')"/>
  <xsl:variable name="bss" select="substring-before(substring-after($b, '[SS]'), '[')"/>
  <xsl:choose>
    <xsl:when test="$asi &lt; $bsi">1</xsl:when>
    <xsl:when test="$asi &gt; $bsi">-1</xsl:when>
    <xsl:when test="$ass &lt; $bss">1</xsl:when>
    <xsl:when test="$ass &gt; $bss">-1</xsl:when>
    <xsl:otherwise>0</xsl:otherwise>
  </xsl:choose>
</xsl:template><!-- compare_li_fill -->

<d:para>
Die Zuordnungsliste.
Die Einträge enthalten die Schlüssel
<literal>HS</literal>,
<literal>HB</literal>,
<literal>HL</literal> und <literal>IK</literal>.
</d:para>
<xsl:variable name="g_li_match">
  <xsl:call-template name="list.zip">
    <xsl:with-param name="first" select="$g_li_help"/>
    <xsl:with-param name="second">
      <xsl:value-of select="$g_li_base"/>
      <xsl:if test="$g_nh &gt; $g_nstf + $g_nskf and $g_ns &gt; 0">
        <xsl:call-template name="txt.repeat">
          <xsl:with-param name="txt" select="concat (' ', $g_li_fill)"/>
          <xsl:with-param name="count" select="floor (($g_nh + $g_ns - 1 - $g_nstf - $g_nskf) div $g_ns)"
          />
        </xsl:call-template>
      </xsl:if>
    </xsl:with-param>
    <xsl:with-param name="zipper" select="$g_stylesheetroot/xsl:template [@name = 'zipper_match']"
    />
  </xsl:call-template>
</xsl:variable>

<d:para>
"Zipper" fügt einen Bildverweis in der Hilfe-Vorlage
und eine Bildkennung aus der Bildergeschichte zusammen.
</d:para>
<xsl:template
  name = "zipper_match"
  mode = "list.apply"
  match = "xsl:template [@name = 'zipper_match' and @mode = 'list.apply' and @match]"
>
  <!-- der Eintrag zum Bildverweis in der Hilfe-Vorlage -->
  <xsl:param name="first"/>
  <!-- der Eintrag aus der Bildergeschichte -->
  <xsl:param name="second"/>
  <xsl:if test="string-length ($first) &gt; 0">
    <xsl:variable name="hs" select="substring-before (substring-after ($first,  '[HS]'), '[')"
    />
    <xsl:variable name="hb" select="substring-before (substring-after ($first,  '[HB]'), '[')"
    />
    <xsl:variable name="hl" select="substring-before (substring-after ($first,  '[HL]'), '[')"
    />
    <xsl:variable name="ik" select="substring-before (substring-after ($second, '[IK]'), '[')"
    />
    <xsl:value-of select="concat ('[HS]', $hs, '[HB]', $hb, '[HL]', $hl, '[IK]', $ik, '[')"
    />
  </xsl:if>
</xsl:template>

<d:para>Bild-ID zu einem Bildverweis</d:para>
<xsl:template match="ht:span[@class = 'imglink']" mode="get_id">
  <!-- Position des Bildverweises -->
  <xsl:variable name="hl" select="count (preceding::ht:span [@class = 'imglink'])"/>
  <!-- die Zuordnung -->
  <xsl:variable name="li">
    <xsl:call-template name="list.entry_by_key">
      <xsl:with-param name="list" select="$g_li_match"/>
      <xsl:with-param name="key" select="concat ('[HL]', $hl + 1, '[')"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:variable name="hs" select="substring-before(substring-after($li, '[HS]'), '[')"/>
  <xsl:variable name="hb" select="substring-before(substring-after($li, '[HB]'), '[')"/>
  <xsl:variable name="ik" select="substring-before(substring-after($li, '[IK]'), '[')"/>
  <xsl:value-of select="concat ('s', $hs, '_', $ik, '_', $hl - $hb)"/>
</xsl:template>

<d:para>Verweis auf ein Vorschaubild in einem Abschnitt</d:para>
<xsl:template match="ht:span[@class = 'imglink']">
  <xsl:variable name="id">
    <xsl:apply-templates select="." mode="get_id"/>
  </xsl:variable>
  <span class="imglink" id="span_{$id}">
    <xsl:apply-templates/>
  </span>
</xsl:template>

<d:para>
Eine Stylesheet-Anweisung wird eingefügt.
</d:para>
<xsl:template match="/">
  <xsl:processing-instruction name="xml-stylesheet">
    <xsl:text>href="desktop_help.xslt" type="application/xml"</xsl:text>
  </xsl:processing-instruction>
  <xsl:apply-templates/>
</xsl:template>

<d:para>Elemente absteigend kopieren</d:para>
<xsl:template match="ht:*">
  <xsl:copy>
    <xsl:apply-templates select="@* | * | text()"/>
  </xsl:copy>
</xsl:template>

<d:para>
Im Kopf wird die Kennung der Bildergeschichte eingefügt
</d:para>
<xsl:template match="ht:head">
  <xsl:copy>
    <xsl:apply-templates select="@* | * | text()"/>
    <xsl:variable name="d">
      <xsl:call-template name="txt.tolastchar">
        <xsl:with-param name="txt" select="$p_fnstory"/>
        <xsl:with-param name="delim" select="'/\'"/>
      </xsl:call-template>
    </xsl:variable>
    <xsl:variable name="d2">
      <xsl:call-template name="txt.afterlastchar">
        <xsl:with-param name="txt" select="substring ($d, 1, string-length ($d) - 1)"/>
        <xsl:with-param name="delim" select="'/\'"/>
      </xsl:call-template>
    </xsl:variable>
    <is:meta name="story">
      <xsl:choose>
        <xsl:when test="starts-with ($d2, 'story_')">
          <xsl:value-of select="substring-after ($d2, 'story_')"/>
        </xsl:when>
        <xsl:when test="starts-with ($d2, 's')">
          <xsl:value-of select="substring-after ($d2, 's')"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="$d2"/>
        </xsl:otherwise>
      </xsl:choose>
    </is:meta>
  </xsl:copy>
</xsl:template>

<d:para>
Zu Abschnitten ohne Bildverweise werden "leere" Bildverweise eingefügt
</d:para>
<xsl:template match="ht:body/ht:div">
  <xsl:copy>
    <xsl:apply-templates select="@* | * | text()"/>
    <xsl:if test="not (.//ht:span[@class = 'imglink'])">
      <xsl:variable name="ih" select="count(preceding-sibling::ht:div) + 1"/>
      <xsl:variable name="li">
        <xsl:call-template name="list.entry_by_key">
          <xsl:with-param name="list" select="$g_ls_zipped"/>
          <xsl:with-param name="key" select="concat ('[HS]', $ih, '[')"/>
        </xsl:call-template>
      </xsl:variable>
      <xsl:choose>
        <xsl:when test="string-length ($li) &gt; 0">
          <xsl:variable name="ss" select="substring-before (substring-after ($li, '[SS]'), '[')"
          />
          <xsl:apply-templates select="$g_sections[position() = $ss] // is:jpg" mode="emptyimg"
          >
            <xsl:with-param name="ih" select="$ih"/>
          </xsl:apply-templates>
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates select="$g_sections [1]" mode="emptyimg">
            <xsl:with-param name="ih" select="$ih"/>
          </xsl:apply-templates>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:if>
  </xsl:copy>
</xsl:template>

<d:para>"Leere" Bildverweise zu einem Hilfe-Abschnitt ohne Bildverweis</d:para>
<xsl:template match="is:section" mode="emptyimg">
  <!-- Die Nummer des Hilfe-Abschnitts -->
  <xsl:param name="ih"/>
  <!-- Lfd. Nummer des Bildes innerhalb des Hilfe-Abschnitts -->
  <xsl:param name="lh" select="0"/>
  <xsl:choose>
    <xsl:when test=".//is:jpg">
      <xsl:variable name="ls" select="($ih - 1) mod count (.//is:jpg) + 1"/>
      <span id="{concat ('span_s', $ih, '_', (.//is:jpg)[$ls]/@src, '_', $lh)}" class="imglink"
      />
      <xsl:apply-templates select="following-sibling::is:section[1]" mode="emptyimg">
        <xsl:with-param name="ih" select="$ih"/>
        <xsl:with-param name="lh" select="$lh + 1"/>
      </xsl:apply-templates>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates select="following-sibling::is:section[1]" mode="emptyimg">
        <xsl:with-param name="ih" select="$ih"/>
        <xsl:with-param name="lh" select="$lh"/>
      </xsl:apply-templates>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<d:para>"Leerer" Bildverweis zu einem Hilfe-Abschnitt ohne Bildverweis</d:para>
<xsl:template match="is:jpg" mode="emptyimg">
  <!-- Die Nummer des Hilfe-Abschnitts -->
  <xsl:param name="ih"/>
  <span id="{concat ('span_s', $ih, '_', @src, '_', position() - 1)}" class="imglink"/>
</xsl:template>

<d:para>Attribute "normalisieren"</d:para>
<xsl:template match="@*">
  <xsl:copy>
    <xsl:value-of select="normalize-space(.)"/>
  </xsl:copy>
</xsl:template>

<d:para>Text normalisieren</d:para>
<xsl:template match="text()">
  <xsl:variable name="tmp" select="normalize-space (concat ('x', ., 'x'))"/>
  <xsl:value-of select="substring ($tmp, 2, string-length ($tmp) - 2)"/>
</xsl:template>

</xsl:stylesheet>
