diff --git a/documentation/algorithmdevelopers/algorithmdebugging.html b/documentation/algorithmdevelopers/algorithmdebugging.html
index c8fe6e5..b2398e0 100644
--- a/documentation/algorithmdevelopers/algorithmdebugging.html
+++ b/documentation/algorithmdevelopers/algorithmdebugging.html
@@ -87,11 +87,11 @@
 </ol>
 <h2 id="logging-mechanisms">Logging Mechanisms</h2>
 <p>Layout algorithms extend the <code>AbstractLayoutProvider</code> class and thus implement the following method:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>ElkNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor monitor<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>ElkNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor monitor<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
     <span style="color:#f92672">...</span>
 <span style="color:#f92672">}</span>
 </code></pre></div><p>The key entry point to everything concerning logging is the <code>IElkProgressMonitor</code>. Here&rsquo;s how to use it:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>ElkNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor monitor<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>ElkNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor monitor<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
     monitor<span style="color:#f92672">.</span><span style="color:#a6e22e">begin</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;TestAlgorithm&#34;</span><span style="color:#f92672">,</span> 2<span style="color:#f92672">);</span>
 
     monitor<span style="color:#f92672">.</span><span style="color:#a6e22e">log</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;Algorithm starting...&#34;</span><span style="color:#f92672">);</span>
@@ -183,7 +183,7 @@
 </li>
 </ul>
 <p>To take proper advantage of the layout time view, your algorithm must make proper use of the <code>IElkProgressMonitor</code> passed to it. The tree of progress monitors (and sub-monitors) is what gets displayed in the layout time view. Be sure to do something like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">monitor<span style="color:#f92672">.</span><span style="color:#a6e22e">begin</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;My rather good layout algorithm&#34;</span><span style="color:#f92672">,</span> 2<span style="color:#f92672">);</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">monitor<span style="color:#f92672">.</span><span style="color:#a6e22e">begin</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;My rather good layout algorithm&#34;</span><span style="color:#f92672">,</span> 2<span style="color:#f92672">);</span>
 
 <span style="color:#75715e">// Phases of your algorithm should use sub-monitors
 </span><span style="color:#75715e"></span>executePhase1<span style="color:#f92672">(</span>monitor<span style="color:#f92672">.</span><span style="color:#a6e22e">subTask</span><span style="color:#f92672">(</span>1<span style="color:#f92672">));</span>
@@ -375,7 +375,7 @@
 </li>
 </ul>
 <p>If automatic layout is not used from inside Eclipse, the progress monitors must be configured manually before being passed to the <a href="../../documentation/tooldevelopers/usingplainjavalayout.html">graph layout engine</a> or directly to the <a href="../../documentation/tooldevelopers/usingalgorithmsdirectly.html">layout algorithm</a>:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">new</span> BasicProgressMonitor<span style="color:#f92672">()</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">new</span> BasicProgressMonitor<span style="color:#f92672">()</span>
     <span style="color:#f92672">.</span><span style="color:#a6e22e">withLogging</span><span style="color:#f92672">(</span><span style="color:#66d9ef">true</span><span style="color:#f92672">)</span>
     <span style="color:#f92672">.</span><span style="color:#a6e22e">withLogPersistence</span><span style="color:#f92672">(</span><span style="color:#66d9ef">false</span><span style="color:#f92672">)</span>
     <span style="color:#f92672">.</span><span style="color:#a6e22e">withExecutionTimeMeasurement</span><span style="color:#f92672">(</span><span style="color:#66d9ef">false</span><span style="color:#f92672">);</span>
diff --git a/documentation/algorithmdevelopers/algorithmimplementation.html b/documentation/algorithmdevelopers/algorithmimplementation.html
index 2ced10d..c8c45f9 100644
--- a/documentation/algorithmdevelopers/algorithmimplementation.html
+++ b/documentation/algorithmdevelopers/algorithmimplementation.html
@@ -77,7 +77,7 @@
 <p>While developing your algorithm, you will regularly switch back and forth between doing that and changing <a href="../../documentation/algorithmdevelopers/metadatalanguage.html">your metadata</a>.</p>
 <h2 id="your-algorithms-main-class">Your Algorithm&rsquo;s Main Class</h2>
 <p>However many classes a layout algorithm consists of, it always provides one entry class that inherits from <code>AbstractLayoutProvider</code> and implements the single most important method for your algorithm:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>ElkNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor progressMonitor<span style="color:#f92672">);</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>ElkNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor progressMonitor<span style="color:#f92672">);</span>
 </code></pre></div><p>Let&rsquo;s go through the parameters in reverse order (because of reasons). The <code>progressMonitor</code> parameter should be used to track progress and check if the user wants to cancel the layout operation. Actually canceling when the user wants to cancel is one of those features that will help your software stand out from many other programs, so take this opportunity to shine!</p>
 <p>The <code>layoutGraph</code> parameter is more important, however. It defines the layout problem your algorithm should solve, in several ways. First, it defines the structure of the graph to be laid out: which nodes exist, how are they connected, and so on. Second, each graph element can have <a href="../../documentation/tooldevelopers/graphdatastructure/layoutoptions.html">layout options</a> attached to it that are supposed to influence what your layout algorithm does with them. And third, each element may have pre-existing <a href="../../documentation/tooldevelopers/graphdatastructure/coordinatesystem.html">coordinates or bend points</a> associated with it that your algorithm may want to make use of. Those existing coordinates will be overwritten by your algorithm to hold the new, computed coordinates.</p>
 <p>Note that the layout graph may contain nodes that themselves contain further nodes. By default, layout algorithms are only supposed to compute coordinates for the direct children of the <code>layoutGraph</code> and then set the size for the <code>layoutGraph</code> itself. However, if your layout algorithm supports hierarchical layout, and if hierarchical layout is requested (which is done through the <code>CoreOptions.HIERARCHY_HANDLING</code> layout option), you will also compute coordinates for children of children.</p>
@@ -110,7 +110,7 @@
   />
 </p>
 
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">progressMonitor<span style="color:#f92672">.</span><span style="color:#a6e22e">begin</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;Simple layout&#34;</span><span style="color:#f92672">,</span> 2<span style="color:#f92672">);</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">progressMonitor<span style="color:#f92672">.</span><span style="color:#a6e22e">begin</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;Simple layout&#34;</span><span style="color:#f92672">,</span> 2<span style="color:#f92672">);</span>
         
 <span style="color:#75715e">// Retrieve several properties
 </span><span style="color:#75715e"></span>ElkPadding padding <span style="color:#f92672">=</span> layoutGraph<span style="color:#f92672">.</span><span style="color:#a6e22e">getProperty</span><span style="color:#f92672">(</span>SimpleOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">PADDING</span><span style="color:#f92672">);</span>
diff --git a/documentation/algorithmdevelopers/algorithmimplementation/algorithmstructure.html b/documentation/algorithmdevelopers/algorithmimplementation/algorithmstructure.html
index 7aabbc7..290f339 100644
--- a/documentation/algorithmdevelopers/algorithmimplementation/algorithmstructure.html
+++ b/documentation/algorithmdevelopers/algorithmimplementation/algorithmstructure.html
@@ -94,7 +94,7 @@
 <p>This example already highlights a difference between layout phases and layout processors: layout phases can request layout processors to be executed in a specific processing slot. Of course, different layout phase implementations can request different processors, resulting in different pipelines. Also, if multiple processors are to be executed in a pipeline, they usually need to be sorted according to their dependencies. A processor that calculates the amount of space around a node required by labels will need a processor that places these labels to have finished executing.</p>
 <h2 id="the-implementation">The Implementation</h2>
 <p>ELK contains everything required to implement layout algorithms this way in its <code>org.eclipse.elk.core.alg</code> package. To use that, the first thing you should start with is to write an enumeration that lists all the phases your algorithm will consist of. For example:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">enum</span> LayoutPhases <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">enum</span> LayoutPhases <span style="color:#f92672">{</span>
 
     P1_TREEIFICATION<span style="color:#f92672">,</span>
     P2_NODE_ORDERING<span style="color:#f92672">,</span>
@@ -104,7 +104,7 @@
 <span style="color:#f92672">}</span>
 </code></pre></div><h3 id="layout-phases">Layout Phases</h3>
 <p>It is now time to start writing your phases. Implementing a layout phase is, in principle, easy: simply have your phase class implement the <code>ILayoutPhase&lt;P, G&gt;</code> interface, where <code>P</code> is the enumeration of layout phases you just wrote, and <code>G</code> is the type of the graph processed by the phase. For example:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">NodeOrderer</span> <span style="color:#66d9ef">implements</span> ILayoutPhase<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">NodeOrderer</span> <span style="color:#66d9ef">implements</span> ILayoutPhase<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#f92672">{</span>
 
     <span style="color:#a6e22e">@Override</span>
     <span style="color:#66d9ef">public</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#a6e22e">getLayoutProcessorConfiguration</span><span style="color:#f92672">(</span>ElkNode graph<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
@@ -118,7 +118,7 @@
 </code></pre></div><p>Besides the actual implementation in its <code>process(...)</code> method, a layout phase has one other interesting method: <code>getLayoutProcessorConfiguration(...)</code>. We will take a closer look at that a bit later. Before we can do that, we need to take a look at how to implement intermediate processors.</p>
 <h3 id="intermediate-processors">Intermediate Processors</h3>
 <p>Implementing a layout processor is, again, easy: simply have your processor class implement the <code>ILayoutProcessor&lt;G&gt;</code> interface, where <code>G</code> is the type of the graph processed by the processor. For example:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">RatherExcellentProcessor</span> <span style="color:#66d9ef">implements</span> ILayoutProcessor<span style="color:#f92672">&lt;</span>ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">RatherExcellentProcessor</span> <span style="color:#66d9ef">implements</span> ILayoutProcessor<span style="color:#f92672">&lt;</span>ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#f92672">{</span>
 
     <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">process</span><span style="color:#f92672">(</span>ElkNode theGraph<span style="color:#f92672">,</span> IElkProgressMonitor monitor<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
         <span style="color:#75715e">// This will be the entry point to your processor
@@ -127,7 +127,7 @@
 <span style="color:#f92672">}</span>
 </code></pre></div><h3 id="specifying-dependencies-from-phases-to-processors">Specifying Dependencies from Phases to Processors</h3>
 <p>Before we can specify dependencies, we will need an enumeration of all available layout processors. In fact, we will need factories to instantiate those processors, but using an enumeration can give us a simple way to implement those. For example:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">enum</span> IntermediateProcessorStrategy <span style="color:#66d9ef">implements</span> ILayoutProcessorFactory<span style="color:#f92672">&lt;</span>ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">enum</span> IntermediateProcessorStrategy <span style="color:#66d9ef">implements</span> ILayoutProcessorFactory<span style="color:#f92672">&lt;</span>ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#f92672">{</span>
 
     <span style="color:#75715e">// Before Phase 2
 </span><span style="color:#75715e"></span>    ROOT_PROC<span style="color:#f92672">,</span>
@@ -170,7 +170,7 @@
     <span style="color:#f92672">}</span>
 <span style="color:#f92672">}</span>
 </code></pre></div><p>We are now ready to specify which layout processors a layout phase needs to be executed in which intermediate processing slots. This is what the phase&rsquo;s <code>getLayoutProcessorConfiguration(...)</code> method is for. That method returns an instance of <code>LayoutProcessorConfiguration&lt;P, G&gt;</code>, which specifies exactly that: the intermediate processors to add to the different processing slots. Which processors are required may well depend on the input graph, which explains why that graph is passed to the method. A simple implementation could look like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">private</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">final</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> INTERMEDIATE_PROCESSING_CONFIG <span style="color:#f92672">=</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">private</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">final</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> INTERMEDIATE_PROCESSING_CONFIG <span style="color:#f92672">=</span>
         LayoutProcessorConfiguration<span style="color:#f92672">.&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span>create<span style="color:#f92672">()</span>
             <span style="color:#f92672">.</span><span style="color:#a6e22e">addBefore</span><span style="color:#f92672">(</span>LayoutPhases<span style="color:#f92672">.</span><span style="color:#a6e22e">P2_NODE_ORDERING</span><span style="color:#f92672">,</span> IntermediateProcessorStrategy<span style="color:#f92672">.</span><span style="color:#a6e22e">ROOT_PROC</span><span style="color:#f92672">)</span>
             <span style="color:#f92672">.</span><span style="color:#a6e22e">addBefore</span><span style="color:#f92672">(</span>LayoutPhases<span style="color:#f92672">.</span><span style="color:#a6e22e">P2_NODE_ORDERING</span><span style="color:#f92672">,</span> IntermediateProcessorStrategy<span style="color:#f92672">.</span><span style="color:#a6e22e">FAN_PROC</span><span style="color:#f92672">);</span>
@@ -180,13 +180,13 @@
     <span style="color:#66d9ef">return</span> INTERMEDIATE_PROCESSING_CONFIG<span style="color:#f92672">;</span>
 <span style="color:#f92672">}</span>
 </code></pre></div><p>This implementation specifies that the processing slot before phase 2 should contain the <code>ROOT_PROC</code> and the <code>FAN_PROC</code> intermediate processors (whatever those are). If multiple processors should be added to the same slots, the following provides a marginally easier way to do so:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">private</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">final</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> INTERMEDIATE_PROCESSING_CONFIG <span style="color:#f92672">=</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">private</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">final</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> INTERMEDIATE_PROCESSING_CONFIG <span style="color:#f92672">=</span>
         LayoutProcessorConfiguration<span style="color:#f92672">.&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span>create<span style="color:#f92672">()</span>
             <span style="color:#f92672">.</span><span style="color:#a6e22e">before</span><span style="color:#f92672">(</span>LayoutPhases<span style="color:#f92672">.</span><span style="color:#a6e22e">P2_NODE_ORDERING</span><span style="color:#f92672">)</span>
                 <span style="color:#f92672">.</span><span style="color:#a6e22e">add</span><span style="color:#f92672">(</span>IntermediateProcessorStrategy<span style="color:#f92672">.</span><span style="color:#a6e22e">ROOT_PROC</span><span style="color:#f92672">)</span>
                 <span style="color:#f92672">.</span><span style="color:#a6e22e">add</span><span style="color:#f92672">(</span>IntermediateProcessorStrategy<span style="color:#f92672">.</span><span style="color:#a6e22e">FAN_PROC</span><span style="color:#f92672">);</span>
 </code></pre></div><p>It can be necessary to keep different configurations in our phase and assemble them depending on different graph features. <code>LayoutProcessorConfiguration</code> provides a way to do so, using the <code>addAll(...)</code> method:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">private</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">final</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> FOO_PROCESSING_ADDITIONS <span style="color:#f92672">=</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">private</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">final</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> FOO_PROCESSING_ADDITIONS <span style="color:#f92672">=</span>
         LayoutProcessorConfiguration<span style="color:#f92672">.&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span>create<span style="color:#f92672">()</span>
             <span style="color:#f92672">.</span><span style="color:#a6e22e">addBefore</span><span style="color:#f92672">(</span>LayoutPhases<span style="color:#f92672">.</span><span style="color:#a6e22e">P3_NODE_PLACEMENT</span><span style="color:#f92672">,</span> IntermediateProcessorStrategy<span style="color:#f92672">.</span><span style="color:#a6e22e">LEVEL_HEIGHT</span><span style="color:#f92672">)</span>
             <span style="color:#f92672">.</span><span style="color:#a6e22e">addBefore</span><span style="color:#f92672">(</span>LayoutPhases<span style="color:#f92672">.</span><span style="color:#a6e22e">P4_EDGE_ROUTING</span><span style="color:#f92672">,</span> IntermediateProcessorStrategy<span style="color:#f92672">.</span><span style="color:#a6e22e">NODE_POSITION_PROC</span><span style="color:#f92672">);</span>
@@ -207,7 +207,7 @@
 </code></pre></div><h3 id="assembling-the-algorithm">Assembling the Algorithm</h3>
 <p>By now, we have phases, processors, a processor enumeration, and dependencies from phases to processors. What we do not have yet is a way to turn those configurations into a pipeline of layout processors that we can execute to compute a layout. What we are looking for is the <code>AlgorithmAssembler</code> class. But before we can use that, we need factories to create our layout phases.</p>
 <p>Again, enumerations are a good way to implement those factories. For example:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">enum</span> NodeOrderStrategy <span style="color:#66d9ef">implements</span> ILayoutPhaseFactory<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">enum</span> NodeOrderStrategy <span style="color:#66d9ef">implements</span> ILayoutPhaseFactory<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> <span style="color:#f92672">{</span>
 
     NODE_ORDERER<span style="color:#f92672">,</span>
     ORDER_BALANCER<span style="color:#f92672">;</span>
@@ -230,7 +230,7 @@
 <span style="color:#f92672">}</span>
 </code></pre></div><p>Turning this into a separate enumeration allows this enumeration to be used as a layout option value for clients to specify which implementation they want.</p>
 <p>We are now ready to assemble the whole algorithm, for example like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">private</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">final</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> OTHER_PROCESSORS <span style="color:#f92672">=</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">private</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">final</span> LayoutProcessorConfiguration<span style="color:#f92672">&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span> OTHER_PROCESSORS <span style="color:#f92672">=</span>
         LayoutProcessorConfiguration<span style="color:#f92672">.&lt;</span>LayoutPhases<span style="color:#f92672">,</span> ElkNode<span style="color:#f92672">&gt;</span>create<span style="color:#f92672">()</span>
             <span style="color:#f92672">.</span><span style="color:#a6e22e">addAfter</span><span style="color:#f92672">(</span>LayoutPhases<span style="color:#f92672">.</span><span style="color:#a6e22e">P4_EDGE_ROUTING</span><span style="color:#f92672">,</span> IntermediateProcessorStrategy<span style="color:#f92672">.</span><span style="color:#a6e22e">DETREEIFYING_PROC</span><span style="color:#f92672">);</span>
 
diff --git a/documentation/algorithmdevelopers/metadatalanguage.html b/documentation/algorithmdevelopers/metadatalanguage.html
index 0118926..35f77a9 100644
--- a/documentation/algorithmdevelopers/metadatalanguage.html
+++ b/documentation/algorithmdevelopers/metadatalanguage.html
@@ -124,7 +124,7 @@
 <li>Which layout algorithm categories your plug-in contributes, and which of them your algorithms belong to.</li>
 </ul>
 <p>The basic layout of a metadata file looks something like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-plain" data-lang="plain">&lt;package declaration&gt;
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-plain" data-lang="plain">&lt;package declaration&gt;
 
 &lt;imports section&gt;
 
@@ -273,7 +273,7 @@
 </code></pre><p>Groups do not just make the metadata file more readable, but also have an effect on the identifiers of your options: all the names of groups your options are in will be placed between the option ID prefix and the option&rsquo;s actual name, thus reflecting the grouping in option IDs as well.</p>
 <h4 id="a-note-on-enumerations">A Note on Enumerations</h4>
 <p>Layout options may well have an enumeration value type. Just as layout options can be declared to be advanced, this may also be true for enumeration values. Take for example a layout algorithm that offers different implementations of a certain feature. The implementation to be used is specified through a layout option that enumerates all possibilities. However, let us assume that some of the implementations are not quite ready for the public. (Homework assignment: work out five reasons why this could be the case.) The corresponding enumeration values can be annotated to make this clear:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">enum</span> Strategy <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">enum</span> Strategy <span style="color:#f92672">{</span>
     WORKS_ALWAYS<span style="color:#f92672">,</span>
     WORKS_ON_SUNDAYS<span style="color:#f92672">,</span>
     <span style="color:#a6e22e">@AdvancedPropertyValue</span>
diff --git a/documentation/algorithmdevelopers/metadatalanguage/automaticbuilds.html b/documentation/algorithmdevelopers/metadatalanguage/automaticbuilds.html
index 7215b10..3d620d5 100644
--- a/documentation/algorithmdevelopers/metadatalanguage/automaticbuilds.html
+++ b/documentation/algorithmdevelopers/metadatalanguage/automaticbuilds.html
@@ -75,7 +75,7 @@
 
     <p>Since <code>.melk</code> files result in code being generated, you may not want to check that code into your repository. Instead, the code should probably be generated as part of your automatic build. Indeed, the ELK metadata language compiler is available through a Maven repository. You can find the repository URLs in our Downloads section. Note that we provide a separate repository for nightly builds and for each release.</p>
 <p>To use the compiler, add the following to your <code>pom.xml</code>:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;pluginRepositories&gt;</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;pluginRepositories&gt;</span>
   <span style="color:#75715e">&lt;!-- Xtext is required to invoke our compiler. --&gt;</span>
   <span style="color:#f92672">&lt;pluginRepository&gt;</span>
     <span style="color:#f92672">&lt;id&gt;</span>xtend<span style="color:#f92672">&lt;/id&gt;</span>
diff --git a/documentation/algorithmdevelopers/unittesting.html b/documentation/algorithmdevelopers/unittesting.html
index 62a8bb6..37bdb39 100644
--- a/documentation/algorithmdevelopers/unittesting.html
+++ b/documentation/algorithmdevelopers/unittesting.html
@@ -113,7 +113,7 @@
 <p>Writing unit tests isn&rsquo;t too hard. This page should walk you through writing and running them.</p>
 <h2 id="adding-a-test-class">Adding a Test Class</h2>
 <p>Unit tests should be placed in a plug-in inside the <code>test</code> folder that depends on our <code>org.eclipse.elk.alg.test</code> plug-in. All class names that end with <code>Test</code> are executed during the automatic build. A minimal test class then looks like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RunWith</span><span style="color:#f92672">(</span>LayoutTestRunner<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RunWith</span><span style="color:#f92672">(</span>LayoutTestRunner<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
 <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">MyAlgorithmTest</span> <span style="color:#f92672">{</span>
 
 <span style="color:#f92672">}</span>
@@ -122,13 +122,13 @@
 <p>There are several way to specify test graphs. There can be arbitrarily many sources for graphs, and all of the ways to specify test graphs can be combined.</p>
 <h3 id="supply-graphs-directly">Supply Graphs Directly</h3>
 <p>You can specify methods that supply graphs built directly in your test class, like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@GraphProvider</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@GraphProvider</span>
 <span style="color:#66d9ef">public</span> ElkNode <span style="color:#a6e22e">produceGraph</span><span style="color:#f92672">()</span> <span style="color:#f92672">{</span>
     <span style="color:#75715e">// Build a graph here...
 </span><span style="color:#75715e"></span><span style="color:#f92672">}</span>
 </code></pre></div><h3 id="load-graphs-from-disk">Load Graphs From Disk</h3>
 <p>Graphs stored in ELK&rsquo;s <a href="https://github.com/eclipse/elk-models">models repository</a> can be used directly in tests. You specify graphs to be loaded through lists of <code>ModelResourcePath</code>, which accepts paths relative to the models repository:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@GraphResourceProvider</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@GraphResourceProvider</span>
 <span style="color:#66d9ef">public</span> List<span style="color:#f92672">&lt;</span>AbstractResourcePath<span style="color:#f92672">&gt;</span> <span style="color:#a6e22e">provideGraphs</span><span style="color:#f92672">()</span> <span style="color:#f92672">{</span>
     List<span style="color:#f92672">&lt;</span>AbstractResourcePath<span style="color:#f92672">&gt;</span> paths <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> ArrayList<span style="color:#f92672">&lt;&gt;();</span>
 
@@ -154,7 +154,7 @@
 <ol>
 <li>
 <p>A method or a field can supply an instance of <code>GeneratorOptions</code> which is used to configure the random graph generator:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RandomGeneratorOptions</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RandomGeneratorOptions</span>
 <span style="color:#66d9ef">public</span> GeneratorOptions <span style="color:#a6e22e">generatorOptions</span><span style="color:#f92672">()</span> <span style="color:#f92672">{</span>
     GeneratorOptions options <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> GeneratorOptions<span style="color:#f92672">();</span>
 
@@ -166,7 +166,7 @@
 </code></pre></div></li>
 <li>
 <p>An <code>.elkr</code> file that specifies options can be loaded, similar to how graphs can be loaded:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RandomGeneratorFile</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RandomGeneratorFile</span>
 <span style="color:#66d9ef">public</span> AbstractResourcePath <span style="color:#a6e22e">loadRandomGraph</span><span style="color:#f92672">()</span> <span style="color:#f92672">{</span>
     <span style="color:#66d9ef">return</span> <span style="color:#66d9ef">new</span> ModelResourcePath<span style="color:#f92672">(</span><span style="color:#e6db74">&#34;path/to/random/graph/file.elkr&#34;</span><span style="color:#f92672">);</span>
 <span style="color:#f92672">}</span>
@@ -176,7 +176,7 @@
 <p>If you simply want to layout the graphs as specified and then run your tests on the results, you can skip this step. However, to test particular features and algorithms it is often necessary to customize layout properties. Again, there are several ways to do so.</p>
 <h3 id="supply-layout-configurators">Supply Layout Configurators</h3>
 <p>Layout configurators are objects that can apply properties to graph objects. You can supply them like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@ConfiguratorProvider</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@ConfiguratorProvider</span>
 <span style="color:#66d9ef">public</span> LayoutConfigurator <span style="color:#a6e22e">configurator</span><span style="color:#f92672">()</span> <span style="color:#f92672">{</span>
     LayoutConfigurator layoutConfig <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> LayoutConfigurator<span style="color:#f92672">();</span>
 
@@ -187,19 +187,19 @@
 <span style="color:#f92672">}</span>
 </code></pre></div><h3 id="configure-graphs-dynamically">Configure Graphs Dynamically</h3>
 <p>You can also define a method that expects a graph and configures that graph dynamically. That allows you to set your properties only if certain conditions are met, for example.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@Configurator</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@Configurator</span>
 <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">configureStuff</span><span style="color:#f92672">(</span><span style="color:#66d9ef">final</span> ElkNode graph<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
     graph<span style="color:#f92672">.</span><span style="color:#a6e22e">setProperty</span><span style="color:#f92672">(</span>SOME_PROPERTY<span style="color:#f92672">,</span> SOME_PROPERTY_VALUE<span style="color:#f92672">);</span>
 <span style="color:#f92672">}</span>
 </code></pre></div><h3 id="specify-layout-algorithms">Specify Layout Algorithms</h3>
 <p>Since specifying a layout algorithm is a common scenario, there are special annotations to do so that can be added to a class. To test one or more specific algorithms, use one or more <code>@Algorithm</code> annotations:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RunWith</span><span style="color:#f92672">(</span>LayoutTestRunner<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RunWith</span><span style="color:#f92672">(</span>LayoutTestRunner<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
 <span style="color:#a6e22e">@Algorithm</span><span style="color:#f92672">(</span>MyTestClassOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">ALGORITHM_ID</span><span style="color:#f92672">)</span>
 <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">MyAlgorithmTest</span> <span style="color:#f92672">{</span>
 
 <span style="color:#f92672">}</span>
 </code></pre></div><p>To test all known algorithms, you can use the <code>@AllAlgorithms</code> annotation instead having to specify all algorithms explicitly:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RunWith</span><span style="color:#f92672">(</span>LayoutTestRunner<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RunWith</span><span style="color:#f92672">(</span>LayoutTestRunner<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
 <span style="color:#a6e22e">@AllAlgorithms</span>
 <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">MyAlgorithmTest</span> <span style="color:#f92672">{</span>
 
@@ -207,7 +207,7 @@
 </code></pre></div><p>Each graph with each configuration is laid out once with each specified algorithm.</p>
 <h3 id="default-configurations">Default Configurations</h3>
 <p>Many graphs in our models repository refrain from specifying explicit sizes and labels for diagram elements. Often, however, tests need nodes to have a size and labels. Thus, your test class can specify to apply default configurations to all diagram elements:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RunWith</span><span style="color:#f92672">(</span>LayoutTestRunner<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@RunWith</span><span style="color:#f92672">(</span>LayoutTestRunner<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
 <span style="color:#a6e22e">@Algorithm</span><span style="color:#f92672">(</span>MyTestClassOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">ALGORITHM_ID</span><span style="color:#f92672">)</span>
 <span style="color:#a6e22e">@DefaultConfiguration</span><span style="color:#f92672">(</span>nodes <span style="color:#f92672">=</span> <span style="color:#66d9ef">true</span><span style="color:#f92672">,</span> ports <span style="color:#f92672">=</span> <span style="color:#66d9ef">true</span><span style="color:#f92672">,</span> edges <span style="color:#f92672">=</span> <span style="color:#66d9ef">true</span><span style="color:#f92672">,</span> edgeLabels <span style="color:#f92672">=</span> <span style="color:#66d9ef">false</span><span style="color:#f92672">)</span>
 <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">MyAlgorithmTest</span> <span style="color:#f92672">{</span>
@@ -242,7 +242,7 @@
 <p>The options default to the values shown in the code fragment.</p>
 <h2 id="black-box-tests">Black Box Tests</h2>
 <p>Now that graphs are loaded and configured, black box test methods can examine the layout result:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@Test</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@Test</span>
 <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">testGraphSizeSet</span><span style="color:#f92672">(</span><span style="color:#66d9ef">final</span> ElkNode graph<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
     Assert<span style="color:#f92672">.</span><span style="color:#a6e22e">assertTrue</span><span style="color:#f92672">(</span>
         <span style="color:#e6db74">&#34;The graph size has not been set by the layout algorithm.&#34;</span><span style="color:#f92672">,</span>
@@ -251,7 +251,7 @@
 </code></pre></div><h2 id="white-box-tests">White Box Tests</h2>
 <p>White box tests ensure that an algorithm&rsquo;s internal state matches the developer&rsquo;s expectations. Here we not only examine the overall layout result, but can look inside intermediate results produced as the algorithm progresses.</p>
 <p>A white box test method needs to specify which layout processor(s) it wants to run before or after. It does so like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@TestBeforeProcessor</span><span style="color:#f92672">(</span>NetworkSimplexLayerer<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#a6e22e">@TestBeforeProcessor</span><span style="color:#f92672">(</span>NetworkSimplexLayerer<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
 <span style="color:#a6e22e">@TestAfterProcessor</span><span style="color:#f92672">(</span>NetworkSimplexLayerer<span style="color:#f92672">.</span><span style="color:#a6e22e">class</span><span style="color:#f92672">)</span>
 <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">testNetworkSimplexLayerer</span><span style="color:#f92672">(</span>Object graph<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
     LGraph lGraph <span style="color:#f92672">=</span> <span style="color:#f92672">(</span>LGraph<span style="color:#f92672">)</span> graph<span style="color:#f92672">;</span>
diff --git a/documentation/contributors/buildingelk.html b/documentation/contributors/buildingelk.html
index 4f36ad2..af03105 100644
--- a/documentation/contributors/buildingelk.html
+++ b/documentation/contributors/buildingelk.html
@@ -76,7 +76,7 @@
     <p>ELK is built using <a href="https://maven.apache.org/">Apache Maven</a> in conjunction with <a href="https://eclipse.org/tycho/">Tycho</a> to tell Maven how to build Eclipse projects. There are two parts that can be built: the Eclipse Layout Kernel itself, and the metadata compiler used by the main ELK build. The remainder of this page assumes that you have opened a shell in the <code>build/</code> directory inside your clone of the ELK repository.</p>
 <h2 id="building-elk">Building ELK</h2>
 <p>Execute Maven using the following command line (note that the command line is split in order to improve readability):</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">mvn
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">mvn
     --define elk.metadata.documentation.outputPath<span style="color:#f92672">=</span>/ELK_FOLDER/docs
     -Dmaven.repo.local<span style="color:#f92672">=</span>./mvnrepo
     clean
@@ -91,7 +91,7 @@
 <p>Due to some tycho/surefire issue the unit tests cannot be executed with Java 9 and 10.</p>
 </div>
 <p>The unit tests require our <a href="https://github.com/eclipse/elk-models">models repository</a> to be checked out as well. If it is, the following command line will run the tests (note that the command line is split in order to improve readability):</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">mvn
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">mvn
     --define elk.metadata.documentation.outputPath<span style="color:#f92672">=</span>/ELK_FOLDER/docs
     --define tests.paths.elk-repo<span style="color:#f92672">=</span>/ELK_FOLDER
     --define tests.paths.models-repo<span style="color:#f92672">=</span>/ELK_MODELS_FOLDER
@@ -101,7 +101,7 @@
 </code></pre></div><p>The <code>TEST_RESULTS_FOLDER</code> is a folder where tests can save data about tests that have failed for later inspection.</p>
 <h2 id="building-the-metadata-compiler">Building the Metadata Compiler</h2>
 <p>Execute Maven using the following command line to build the metadata compiler locally (note that the command line is split in order to improve readability):</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">mvn
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">mvn
     -P elk-meta
     -Dmaven.repo.local<span style="color:#f92672">=</span>./mvnrepo
     clean
@@ -109,9 +109,9 @@
 </code></pre></div><h2 id="building-the-website-and-documentation">Building the Website and Documentation</h2>
 <p>The documentation website is our source of documentation. The main build produces reference documentation which is part of the website from our metadata files. The documentation website itself is then built with <a href="https://gohugo.io/">Hugo</a>, a static website generator. The website is setup in a way to be browsable both online and offline.</p>
 <p>To actually build the documentation website, go to the repository&rsquo;s <code>docs/</code> folder and simply execute the following command:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">hugo
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">hugo
 </code></pre></div><p>To edit the website, start a Hugo server instance in the repository&rsquo;s <code>docs/</code> folder:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">hugo server
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-bash" data-lang="bash">hugo server
 </code></pre></div><p>You can then direct your browser to <a href="http://localhost:1313/elk/">http://localhost:1313/elk/</a>. As you edit the website&rsquo;s files and save them, the browser&rsquo;s content is dynamically updated.</p>
 
   </div>
diff --git a/documentation/contributors/developmentworkflow.html b/documentation/contributors/developmentworkflow.html
index 6ae4bd5..be08565 100644
--- a/documentation/contributors/developmentworkflow.html
+++ b/documentation/contributors/developmentworkflow.html
@@ -90,7 +90,7 @@
 <li>
 <p><strong>Proper Commit Messages</strong></p>
 <p>This is an example of what we consider to be a proper commit message:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-plain" data-lang="plain">Core, Layered: Fix labels with layout directions #58
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-plain" data-lang="plain">Core, Layered: Fix labels with layout directions #58
 
 Using node labels inside compound nodes that are configured to use
 different layout directions resulted in problems with calculated insets.
diff --git a/documentation/tooldevelopers/graphdatastructure/jsonformat.html b/documentation/tooldevelopers/graphdatastructure/jsonformat.html
index 8c807e0..4c69ddb 100644
--- a/documentation/tooldevelopers/graphdatastructure/jsonformat.html
+++ b/documentation/tooldevelopers/graphdatastructure/jsonformat.html
@@ -85,7 +85,7 @@
 All elements furthermore can have <a href="../../../reference/options.html"><em>layout options</em></a>.
 Layout options are basically a list of key-value pairs that are used to
 assign layout option values to the element.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">id*:</span> <span style="color:#f92672">&#34;ID&#34;</span>,
   <span style="color:#960050;background-color:#1e0010">layoutOptions:</span> <span style="color:#960050;background-color:#1e0010">{</span> <span style="color:#960050;background-color:#1e0010">..object</span> <span style="color:#960050;background-color:#1e0010">with</span> <span style="color:#960050;background-color:#1e0010">key</span> <span style="color:#960050;background-color:#1e0010">value</span> <span style="color:#960050;background-color:#1e0010">pairs..</span> }
 <span style="color:#960050;background-color:#1e0010">}</span>
@@ -94,7 +94,7 @@
 can also have an arbitrary number of labels to describe them properly. Yes, even labels can
 have labels, although it depends on the layout algorithm whether or not it supports labeled
 labels.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">x:</span> <span style="color:#960050;background-color:#1e0010">...,</span>
   <span style="color:#960050;background-color:#1e0010">y:</span> <span style="color:#960050;background-color:#1e0010">...,</span>
   <span style="color:#960050;background-color:#1e0010">width:</span> <span style="color:#960050;background-color:#1e0010">...,</span>
@@ -108,7 +108,7 @@
 Finally, a node can contain edges. These edges do not necessarily connect to the node, but will
 usually connect its children. The edge coordinates will be interpreted relative to the upper
 left corner of the node which contains it.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">ports:</span> <span style="color:#960050;background-color:#1e0010">[</span> <span style="color:#960050;background-color:#1e0010">..array</span> <span style="color:#960050;background-color:#1e0010">of</span> <span style="color:#960050;background-color:#1e0010">port</span> <span style="color:#960050;background-color:#1e0010">objects..</span> <span style="color:#960050;background-color:#1e0010">],</span>
   <span style="color:#960050;background-color:#1e0010">children:</span> <span style="color:#960050;background-color:#1e0010">[</span> <span style="color:#960050;background-color:#1e0010">..array</span> <span style="color:#960050;background-color:#1e0010">of</span> <span style="color:#960050;background-color:#1e0010">child</span> <span style="color:#960050;background-color:#1e0010">node</span> <span style="color:#960050;background-color:#1e0010">objects..</span> <span style="color:#960050;background-color:#1e0010">],</span>
   <span style="color:#960050;background-color:#1e0010">edges:</span> <span style="color:#960050;background-color:#1e0010">[</span> <span style="color:#960050;background-color:#1e0010">..array</span> <span style="color:#960050;background-color:#1e0010">of</span> <span style="color:#960050;background-color:#1e0010">edge</span> <span style="color:#960050;background-color:#1e0010">objects..</span> <span style="color:#960050;background-color:#1e0010">]</span>
@@ -119,7 +119,7 @@
 <p>Labels can additionally contain text. Note that layout algorithms
 generally don&rsquo;t perform any size estimation of the text.
 Therefore you should specify a reasonable width and height.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">text:</span> <span style="color:#f92672">&#34;A magnificent text&#34;</span>
 }
 </code></pre></div><h2 id="edges">Edges</h2>
@@ -130,7 +130,7 @@
 <h3 id="primitive-edges">Primitive Edges</h3>
 <p>Primitive edges have a source and target node and can optionally connect
 to a source port and target port.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">source*:</span> <span style="color:#960050;background-color:#1e0010">node</span> <span style="color:#960050;background-color:#1e0010">identifier,</span>
   <span style="color:#960050;background-color:#1e0010">sourcePort:</span> <span style="color:#960050;background-color:#1e0010">port</span> <span style="color:#960050;background-color:#1e0010">identifier,</span>
   <span style="color:#960050;background-color:#1e0010">target*:</span> <span style="color:#960050;background-color:#1e0010">node</span> <span style="color:#960050;background-color:#1e0010">identifier,</span>
@@ -147,7 +147,7 @@
 Note that many layout algorithms don&rsquo;t support hyperedges.
 If an edge has a layout, it can specify an arbitrary number of edge sections
 that define said layout. A simple edge with one source and one target only needs a single section.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">sources*:</span> <span style="color:#960050;background-color:#1e0010">[</span> <span style="color:#960050;background-color:#1e0010">..array</span> <span style="color:#960050;background-color:#1e0010">of</span> <span style="color:#960050;background-color:#1e0010">node</span> <span style="color:#960050;background-color:#1e0010">and</span> <span style="color:#960050;background-color:#1e0010">/</span> <span style="color:#960050;background-color:#1e0010">or</span> <span style="color:#960050;background-color:#1e0010">port</span> <span style="color:#960050;background-color:#1e0010">identifiers..</span> <span style="color:#960050;background-color:#1e0010">],</span>
   <span style="color:#960050;background-color:#1e0010">targets*:</span> <span style="color:#960050;background-color:#1e0010">[</span> <span style="color:#960050;background-color:#1e0010">..array</span> <span style="color:#960050;background-color:#1e0010">of</span> <span style="color:#960050;background-color:#1e0010">node</span> <span style="color:#960050;background-color:#1e0010">and</span> <span style="color:#960050;background-color:#1e0010">/</span> <span style="color:#960050;background-color:#1e0010">or</span> <span style="color:#960050;background-color:#1e0010">port</span> <span style="color:#960050;background-color:#1e0010">identifiers..</span> <span style="color:#960050;background-color:#1e0010">],</span>
   <span style="color:#960050;background-color:#1e0010">sections:</span> <span style="color:#960050;background-color:#1e0010">[</span> <span style="color:#960050;background-color:#1e0010">..array</span> <span style="color:#960050;background-color:#1e0010">of</span> <span style="color:#960050;background-color:#1e0010">edge</span> <span style="color:#960050;background-color:#1e0010">sections..</span> <span style="color:#960050;background-color:#1e0010">],</span>
@@ -164,7 +164,7 @@
 runs from the edge&rsquo;s single source to its single target. In this case, it is enough to define
 the section&rsquo;s start and end point and possibly bendpoints.
 Incoming and outgoing shapes are then filled in automatically by the importer.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">startPoint*:</span> <span style="color:#960050;background-color:#1e0010">{x,</span> <span style="color:#960050;background-color:#1e0010">y</span>}<span style="color:#960050;background-color:#1e0010">,</span>
   <span style="color:#960050;background-color:#1e0010">endPoint*:</span> {<span style="color:#960050;background-color:#1e0010">x,</span> <span style="color:#960050;background-color:#1e0010">y</span>}<span style="color:#960050;background-color:#1e0010">,</span>
   <span style="color:#960050;background-color:#1e0010">bendPoints:</span> [ <span style="color:#960050;background-color:#1e0010">..array</span> <span style="color:#960050;background-color:#1e0010">of</span> {<span style="color:#960050;background-color:#1e0010">x,</span> <span style="color:#960050;background-color:#1e0010">y</span>} <span style="color:#960050;background-color:#1e0010">pairs..</span> ]<span style="color:#960050;background-color:#1e0010">,</span>
@@ -180,12 +180,12 @@
 for instance, small circles.
 In case an algorithm computes junction points,
 an edge&rsquo;s representation might look like the following after layout.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">id:</span> <span style="color:#f92672">&#34;edge0&#34;</span>,
   <span style="color:#960050;background-color:#1e0010">junctionPoints:</span> <span style="color:#960050;background-color:#1e0010">[</span> <span style="color:#960050;background-color:#1e0010">..array</span> <span style="color:#960050;background-color:#1e0010">of</span> <span style="color:#960050;background-color:#1e0010">{x,</span> <span style="color:#960050;background-color:#1e0010">y</span>} <span style="color:#960050;background-color:#1e0010">pairs..</span> <span style="color:#960050;background-color:#1e0010">]</span>
 <span style="color:#960050;background-color:#1e0010">}</span>
 </code></pre></div><h1 id="small-example">Small Example</h1>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-json" data-lang="json">{
   <span style="color:#960050;background-color:#1e0010">id:</span> <span style="color:#f92672">&#34;root&#34;</span>,
   <span style="color:#960050;background-color:#1e0010">properties:</span> <span style="color:#960050;background-color:#1e0010">{</span> <span style="color:#f92672">&#34;elk.direction&#34;</span>: <span style="color:#e6db74">&#34;RIGHT&#34;</span> }<span style="color:#960050;background-color:#1e0010">,</span>
   <span style="color:#960050;background-color:#1e0010">children:</span> [
@@ -201,7 +201,7 @@
 It provides a set of methods that are outlined next.</p>
 <h2 id="json-to-elk-graph">JSON to ELK Graph</h2>
 <p>Simple import using a json string as input:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ElkNode root <span style="color:#f92672">=</span> ElkGraphJson<span style="color:#f92672">.</span><span style="color:#a6e22e">forGraph</span><span style="color:#f92672">(</span>jsonString<span style="color:#f92672">)</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ElkNode root <span style="color:#f92672">=</span> ElkGraphJson<span style="color:#f92672">.</span><span style="color:#a6e22e">forGraph</span><span style="color:#f92672">(</span>jsonString<span style="color:#f92672">)</span>
                            <span style="color:#f92672">.</span><span style="color:#a6e22e">toElk</span><span style="color:#f92672">();</span>
 </code></pre></div><p>Sometimes one desires to transfer the computed layout back to
 the initial json graph.
@@ -211,7 +211,7 @@
 the <code>JsonImporter</code> instance that has been used to
 import the json graph. Internally, the importer maintains
 several maps from json elements to ELK graph elements.</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">JsonObject jsonGraph <span style="color:#f92672">=</span> <span style="color:#f92672">...;</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">JsonObject jsonGraph <span style="color:#f92672">=</span> <span style="color:#f92672">...;</span>
 Maybe<span style="color:#f92672">&lt;</span>JsonImporter<span style="color:#f92672">&gt;</span> importerMaybe <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> Maybe<span style="color:#f92672">&lt;&gt;();</span>
 ElkNode root <span style="color:#f92672">=</span> ElkGraphJson<span style="color:#f92672">.</span><span style="color:#a6e22e">forGraph</span><span style="color:#f92672">(</span>jsonGraph<span style="color:#f92672">)</span>
                            <span style="color:#f92672">.</span><span style="color:#a6e22e">rememberImporter</span><span style="color:#f92672">(</span>importerMaybe<span style="color:#f92672">)</span>
@@ -220,7 +220,7 @@
 </span><span style="color:#75715e"></span>
 importerMaybe<span style="color:#f92672">.</span><span style="color:#a6e22e">get</span><span style="color:#f92672">().</span><span style="color:#a6e22e">transferLayout</span><span style="color:#f92672">(</span>root<span style="color:#f92672">);</span>
 </code></pre></div><h2 id="elk-graph-to-json">ELK Graph to JSON</h2>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ElkNode root <span style="color:#f92672">=</span> <span style="color:#f92672">...;</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ElkNode root <span style="color:#f92672">=</span> <span style="color:#f92672">...;</span>
 String json <span style="color:#f92672">=</span> ElkGraphJson<span style="color:#f92672">.</span><span style="color:#a6e22e">forGraph</span><span style="color:#f92672">(</span>root<span style="color:#f92672">)</span>
                           <span style="color:#f92672">.</span><span style="color:#a6e22e">omitLayout</span><span style="color:#f92672">(</span><span style="color:#66d9ef">true</span><span style="color:#f92672">)</span>
                           <span style="color:#f92672">.</span><span style="color:#a6e22e">omitZeroDimension</span><span style="color:#f92672">(</span><span style="color:#66d9ef">true</span><span style="color:#f92672">)</span>
diff --git a/documentation/tooldevelopers/graphdatastructure/layoutoptions.html b/documentation/tooldevelopers/graphdatastructure/layoutoptions.html
index e373c2c..81525a1 100644
--- a/documentation/tooldevelopers/graphdatastructure/layoutoptions.html
+++ b/documentation/tooldevelopers/graphdatastructure/layoutoptions.html
@@ -92,18 +92,18 @@
 <p>There are two aspects of working with properties: accessing them (which is what both users and developers of layout algorithms usually do) and defining properties (which is what developers of layout algorithms sometimes do).</p>
 <h3 id="setting-property-values">Setting Property Values</h3>
 <p>To set a property&rsquo;s value on a property holder, use this code:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ElkGraphElement graphElement <span style="color:#f92672">=</span> <span style="color:#f92672">...;</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ElkGraphElement graphElement <span style="color:#f92672">=</span> <span style="color:#f92672">...;</span>
 graphElement<span style="color:#f92672">.</span><span style="color:#a6e22e">setProperty</span><span style="color:#f92672">(</span>CoreOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">DEBUG_MODE</span><span style="color:#f92672">,</span> <span style="color:#66d9ef">true</span><span style="color:#f92672">);</span>
 </code></pre></div><p>Note that the available property objects used to set property values are</p>
 <h3 id="retrieving-property-values">Retrieving Property Values</h3>
 <p>To get hold of the properties of a graph element, use code such as this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ElkGraphElement graphElement <span style="color:#f92672">=</span> <span style="color:#f92672">...;</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ElkGraphElement graphElement <span style="color:#f92672">=</span> <span style="color:#f92672">...;</span>
 <span style="color:#75715e">// Note that we do not use CoreOptions to access the property
 </span><span style="color:#75715e">// (see below for why that is)
 </span><span style="color:#75715e"></span><span style="color:#66d9ef">boolean</span> debugMode <span style="color:#f92672">=</span> graphElement<span style="color:#f92672">.</span><span style="color:#a6e22e">getProperty</span><span style="color:#f92672">(</span>MyAlgorithmOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">DEBUG_MODE</span><span style="color:#f92672">);</span>
 </code></pre></div><p>Of course, since <code>IProperty</code> is a generic type, there is no explicit type casting involved here. Also, if the <code>MyAlgorithmOptions.DEBUG_MODE</code> property is not set on <code>graphElement</code>, the <code>getProperty(...)</code> method will simply return the property&rsquo;s default value, which in this case is <code>false</code>. Why is it <code>false</code>, though? Where does the default value come from?</p>
 <p>When the <code>getProperty(...)</code> method determines that the property whose value it should retrieve is not actually configured, it asks the passed <code>IProperty</code> instance for the default value to be returned. This has an important consequence. Consider the following code:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">final</span> IProperty<span style="color:#f92672">&lt;</span>Boolean<span style="color:#f92672">&gt;</span> FALSE_DEFAULT <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> Property<span style="color:#f92672">&lt;&gt;(</span><span style="color:#e6db74">&#34;an.excellent.example.property&#34;</span><span style="color:#f92672">,</span> <span style="color:#66d9ef">false</span><span style="color:#f92672">);</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">final</span> IProperty<span style="color:#f92672">&lt;</span>Boolean<span style="color:#f92672">&gt;</span> FALSE_DEFAULT <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> Property<span style="color:#f92672">&lt;&gt;(</span><span style="color:#e6db74">&#34;an.excellent.example.property&#34;</span><span style="color:#f92672">,</span> <span style="color:#66d9ef">false</span><span style="color:#f92672">);</span>
 <span style="color:#66d9ef">final</span> IProperty<span style="color:#f92672">&lt;</span>Boolean<span style="color:#f92672">&gt;</span> TRUE_DEFAULT <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> Property<span style="color:#f92672">&lt;&gt;(</span><span style="color:#e6db74">&#34;an.excellent.example.property&#34;</span><span style="color:#f92672">,</span> <span style="color:#66d9ef">true</span><span style="color:#f92672">);</span>
 
 <span style="color:#75715e">// Setting the property value to null effectively undefines the
@@ -113,13 +113,13 @@
 propertyHolder<span style="color:#f92672">.</span><span style="color:#a6e22e">setProperty</span><span style="color:#f92672">(</span>FALSE_DEFAULT<span style="color:#f92672">,</span> <span style="color:#66d9ef">null</span><span style="color:#f92672">);</span>
 System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span>propertyHolder<span style="color:#f92672">.</span><span style="color:#a6e22e">getProperty</span><span style="color:#f92672">(</span>TRUE_DEFAULT<span style="color:#f92672">));</span>
 </code></pre></div><p>This code will produce the following output:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-plain" data-lang="plain">false
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-plain" data-lang="plain">false
 true
 </code></pre></div><p>This means that you can define multiple <code>IProperty</code> instances that describe the same property, but with different default values. That seems like an inconsistency, but it has an important reason. The layout options known to the Eclipse Layout Kernel are registered with the <code>LayoutMetaDataService</code>. Most are registered with a global default value. Layout algorithms declare which of those options they support, and in doing so can override that default value. Accordingly, they need their own <code>IProperty</code> instance with their own default value to retrieve property values. This is why the ELK metadata tooling generates a separate layout metadata provider for each layout algorithm, complete <code>IProperty</code> objects for each supported layout option to retrieve its value with. Which <code>IProperty</code> object is used to <em>set</em> the property value does not matter, though.</p>
 <p>That is the reason why the first example above does not use <code>CoreOptions.DEBUG_MODE</code> to retrieve the property value, but <code>MyAlgorithmOptions.DEBUG_MODE</code> (where <code>MyAlgorithmOptions</code> is the metadata class generated for your layout algorithm).</p>
 <h3 id="checking-for-the-presence-of-property-values">Checking for the Presence of Property Values</h3>
 <p>We can always call <code>getProperty(...)</code> on a graph element and get a (more or less) sensible result, but we may not be able to distinguish a default value from a value explicitly set on that element. If we need to, we can check whether a property was explicitly set through <code>hasProperty(...)</code>:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">if</span> <span style="color:#f92672">(</span>propertyHolder<span style="color:#f92672">.</span><span style="color:#a6e22e">hasProperty</span><span style="color:#f92672">(</span>MyAlgorithmOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">OPTIONAL_GIZMO</span><span style="color:#f92672">))</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">if</span> <span style="color:#f92672">(</span>propertyHolder<span style="color:#f92672">.</span><span style="color:#a6e22e">hasProperty</span><span style="color:#f92672">(</span>MyAlgorithmOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">OPTIONAL_GIZMO</span><span style="color:#f92672">))</span> <span style="color:#f92672">{</span>
     Gizmo g <span style="color:#f92672">=</span> propertyHolder<span style="color:#f92672">.</span><span style="color:#a6e22e">getProperty</span><span style="color:#f92672">(</span>MyAlgorithmOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">OPTIONAL_GIZMO</span><span style="color:#f92672">);</span>
 <span style="color:#f92672">}</span>
 </code></pre></div><h2 id="defining-properties">Defining Properties</h2>
diff --git a/documentation/tooldevelopers/usingalgorithmsdirectly.html b/documentation/tooldevelopers/usingalgorithmsdirectly.html
index 34ec13a..7505e1b 100644
--- a/documentation/tooldevelopers/usingalgorithmsdirectly.html
+++ b/documentation/tooldevelopers/usingalgorithmsdirectly.html
@@ -77,7 +77,7 @@
 <p><strong>Warning:</strong> This is very low-level stuff. If you want to stay in the pure-Java domain (as opposed to building an Eclipse-based application), you will probably want to use <a href="../../documentation/tooldevelopers/usingplainjavalayout.html">the next layer of abstraction</a>.</p>
 <h2 id="the-entry-point-to-layout-algorithms">The Entry Point to Layout Algorithms</h2>
 <p>When using layout algorithms directly, the central most important type you will deal with is the <code>AbstractLayoutProvider</code> class. A layout provider basically consists of three methods:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">initialize</span><span style="color:#f92672">(</span>String parameter<span style="color:#f92672">);</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">initialize</span><span style="color:#f92672">(</span>String parameter<span style="color:#f92672">);</span>
 <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>KNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor progressMonitor<span style="color:#f92672">);</span>
 <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">dispose</span><span style="color:#f92672">();</span>
 </code></pre></div><p>Each layout algorithm provides a subclass of <code>AbstractLayoutProvider</code> that is the entry point to the algorithm. Using it is a matter of doing the following:</p>
diff --git a/documentation/tooldevelopers/usingeclipselayout/advancedconfiguration.html b/documentation/tooldevelopers/usingeclipselayout/advancedconfiguration.html
index 7e21f76..5f64f40 100644
--- a/documentation/tooldevelopers/usingeclipselayout/advancedconfiguration.html
+++ b/documentation/tooldevelopers/usingeclipselayout/advancedconfiguration.html
@@ -87,7 +87,7 @@
 </li>
 </ul>
 <p>Let&rsquo;s come back to layout configurators and see how they work. Basically, each layout configurator added to your parameters can set an arbitrary number of layout options on different elements of your ElkGraph. Also, it can be configured to clear all previous configuration stored in the graph. To specify the options to set, there are two possibilities. First, you can specify concrete objects in the graph structure to set options on. And second, you can specify whole classes of graph elements to set options on. Here&rsquo;s some example code that should make everything a bit clearer:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">LayoutConfigurator configurator <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> LayoutConfigurator<span style="color:#f92672">();</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">LayoutConfigurator configurator <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> LayoutConfigurator<span style="color:#f92672">();</span>
 
 <span style="color:#75715e">// Configure layout options for a concrete graph object
 </span><span style="color:#75715e"></span>configurator<span style="color:#f92672">.</span><span style="color:#a6e22e">configure</span><span style="color:#f92672">(</span>myVerySpecialNode<span style="color:#f92672">)</span>
@@ -99,7 +99,7 @@
     <span style="color:#f92672">.</span><span style="color:#a6e22e">setProperty</span><span style="color:#f92672">(</span>CoreOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">ALGORITHM</span><span style="color:#f92672">,</span> <span style="color:#e6db74">&#34;org.eclipse.elk.layered&#34;</span><span style="color:#f92672">)</span>
     <span style="color:#f92672">.</span><span style="color:#a6e22e">setProperty</span><span style="color:#f92672">(</span>CoreOptions<span style="color:#f92672">.</span><span style="color:#a6e22e">SPACING_NODE</span><span style="color:#f92672">,</span> 30<span style="color:#f92672">.</span><span style="color:#a6e22e">0f</span><span style="color:#f92672">);</span>
 </code></pre></div><p>This configurator can then be put into a <code>Parameters</code> object that can be passed to the <code>DiagramLayoutEngine</code>:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">DiagramLayoutEngine<span style="color:#f92672">.</span><span style="color:#a6e22e">Parameters</span> params <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> DiagramLayoutEngine<span style="color:#f92672">.</span><span style="color:#a6e22e">Parameters</span><span style="color:#f92672">();</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">DiagramLayoutEngine<span style="color:#f92672">.</span><span style="color:#a6e22e">Parameters</span> params <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> DiagramLayoutEngine<span style="color:#f92672">.</span><span style="color:#a6e22e">Parameters</span><span style="color:#f92672">();</span>
 params<span style="color:#f92672">.</span><span style="color:#a6e22e">addLayoutRun</span><span style="color:#f92672">(</span>configurator<span style="color:#f92672">);</span>
 DiagramLayoutEngine<span style="color:#f92672">.</span><span style="color:#a6e22e">invokeLayout</span><span style="color:#f92672">(</span>workbenchPart<span style="color:#f92672">,</span> diagramPart<span style="color:#f92672">,</span> params<span style="color:#f92672">);</span>
 </code></pre></div><p>The concept of using layout configurators to set layout options on your ElkGraph seems to contradict what we have said so far: that the layout connector is responsible for producing an ElkGraph with options already set. In fact, these do not contradict each other, but are simply two different (but combinable) ways of doing things. There are basically three ways of going about it:</p>
diff --git a/documentation/tooldevelopers/usingeclipselayout/connectingtoelk.html b/documentation/tooldevelopers/usingeclipselayout/connectingtoelk.html
index 40518ad..ac0b107 100644
--- a/documentation/tooldevelopers/usingeclipselayout/connectingtoelk.html
+++ b/documentation/tooldevelopers/usingeclipselayout/connectingtoelk.html
@@ -82,13 +82,13 @@
 <p>The rest of this page will look at each of these in turn.</p>
 <h2 id="the-layout-setup">The Layout Setup</h2>
 <p>An <code>ILayoutSetup</code> implementation consists of just two methods:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">boolean</span> <span style="color:#a6e22e">supports</span><span style="color:#f92672">(</span>Object object<span style="color:#f92672">);</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">boolean</span> <span style="color:#a6e22e">supports</span><span style="color:#f92672">(</span>Object object<span style="color:#f92672">);</span>
 Injector <span style="color:#a6e22e">createInjector</span><span style="color:#f92672">(</span>Module defaultModule<span style="color:#f92672">);</span>
 </code></pre></div><p>To be able to implement the interface, you may have to add a dependency to <code>org.eclipse.elk.core.service</code> to your project. Then register your layout setup with the <code>org.eclipse.elk.core.service.layoutConnectors</code> extension point.</p>
 <h3 id="the-supports-method">The <code>supports(...)</code> Method</h3>
 <p>This method is called by the diagram layout engine to determine if a given setup instance supports extracting an ElkGraph from the given object. The question now of course becomes what that object is. There are two cases. In the first case, it will be an implementation of <code>IWorkbenchPart</code>. This is the case if layout is invoked on a diagram editor. If the setup states that it supports that workbench part, the diagram layout connector it supplies knows how to get its hands at the editor&rsquo;s content and how to turn that content into an ElkGraph. In the second case, the object passed to <code>supports(...)</code> will be an object from that editor&rsquo;s content. For GMF editors, this will be an implementation of <code>IGraphicalEditPart</code>.</p>
 <p>A typical implementation of this method will look something like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">boolean</span> <span style="color:#a6e22e">supports</span><span style="color:#f92672">(</span><span style="color:#66d9ef">final</span> Object object<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">boolean</span> <span style="color:#a6e22e">supports</span><span style="color:#f92672">(</span><span style="color:#66d9ef">final</span> Object object<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
     <span style="color:#75715e">// This method may be invoked on a whole collection of elements selected
 </span><span style="color:#75715e"></span>    <span style="color:#75715e">// in an editor
 </span><span style="color:#75715e"></span>    <span style="color:#66d9ef">if</span> <span style="color:#f92672">(</span>object <span style="color:#66d9ef">instanceof</span> Collection<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
@@ -108,7 +108,7 @@
 <span style="color:#f92672">}</span>
 </code></pre></div><h3 id="the-createinjector-method">The <code>createInjector(...)</code> Method</h3>
 <p>If the diagram layout engine has determined which setup supports layout on a given object, it will use that setup to get its hands on an injector that can supply implementations of the different components involved in the layout process. The most important of these is an implementation of <code>IDiagramLayoutConnector</code>, which we will look at in a minute. A typical implementation will look something like this:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> Injector <span style="color:#a6e22e">createInjector</span><span style="color:#f92672">(</span><span style="color:#66d9ef">final</span> Module defaultModule<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> Injector <span style="color:#a6e22e">createInjector</span><span style="color:#f92672">(</span><span style="color:#66d9ef">final</span> Module defaultModule<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
     <span style="color:#75715e">// Modules basically provide a mapping between types and implementations
 </span><span style="color:#75715e"></span>    <span style="color:#75715e">// to instantiate whenever an instance of the type is requested. We use
 </span><span style="color:#75715e"></span>    <span style="color:#75715e">// the default module supplied by ELK and override that with custom
@@ -128,7 +128,7 @@
 </code></pre></div><p>An implementation can of course add more bindings. See our section on dependency injection for more information on what makes sense here.</p>
 <h2 id="the-layout-connector">The Layout Connector</h2>
 <p>An <code>IDiagramLayoutConnector</code> implementation consists of the following methods:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">LayoutMapping <span style="color:#a6e22e">buildLayoutGraph</span><span style="color:#f92672">(</span>IWorkbenchPart workbenchPart<span style="color:#f92672">,</span> Object diagramPart<span style="color:#f92672">);</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">LayoutMapping <span style="color:#a6e22e">buildLayoutGraph</span><span style="color:#f92672">(</span>IWorkbenchPart workbenchPart<span style="color:#f92672">,</span> Object diagramPart<span style="color:#f92672">);</span>
 <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">applyLayout</span><span style="color:#f92672">(</span>LayoutMapping mapping<span style="color:#f92672">,</span> IPropertyHolder settings<span style="color:#f92672">);</span>
 </code></pre></div><p>These methods pretty much correspond to the beginning and the end of the layout process: extracting the layout graph from whatever layout is invoked on, and applying the layout information back to the diagram. Let&rsquo;s take a look at how these methods should be implemented.</p>
 <h3 id="the-buildlayoutgraph-method">The <code>buildLayoutGraph(...)</code> Method</h3>
diff --git a/documentation/tooldevelopers/usingplainjavalayout.html b/documentation/tooldevelopers/usingplainjavalayout.html
index 0e2a564..b2f3309 100644
--- a/documentation/tooldevelopers/usingplainjavalayout.html
+++ b/documentation/tooldevelopers/usingplainjavalayout.html
@@ -85,7 +85,7 @@
 <p>The best way to invoke automatic layout is through a fully-fledged implementation of <code>IGraphLayoutEngine</code>. ELK provides a convenient implementation: the <code>RecursiveGraphLayoutEngine</code>.</p>
 <h2 id="using-the-recursive-graph-layout-engines">Using the Recursive Graph Layout Engines</h2>
 <p>When using the recursive graph layout engine, there is exactly one important method to be aware of:</p>
-<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>KNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor progressMonitor<span style="color:#f92672">);</span>
+<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">layout</span><span style="color:#f92672">(</span>KNode layoutGraph<span style="color:#f92672">,</span> IElkProgressMonitor progressMonitor<span style="color:#f92672">);</span>
 </code></pre></div><p>This method provides the entry point to automatic layout and applies the layout algorithms as configured in the layout graph (more details below). To get everything working, follow these steps after you have populated the layout meta data service:</p>
 <ol>
 <li>
diff --git a/index.html b/index.html
index 1251485..6e3c417 100644
--- a/index.html
+++ b/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html lang="en">
   <head>
-	<meta name="generator" content="Hugo 0.85.0" />
+	<meta name="generator" content="Hugo 0.86.0" />
     
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">