<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
        <meta charset="utf-8">
        <title>Apache Wicket 6.21.0 released | Apache Wicket</title>
        <meta name="viewport" content="width=device-width, initial-scale=1" />

        <link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon" />
        <link rel="stylesheet" href="/css/style.css" type="text/css" media="screen" />
        <link href="//maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" />

		<script src="//code.jquery.com/jquery-1.11.3.min.js"></script>

    </head>

    <body class="">
        <div class="header default">
    <div class="l-container">
<nav class="mainmenu">
    <ul>
		<!-- /start/quickstart.html || /news/2015/11/16/wicket-6.21.0-released.html -->
    	<li class=""><a href="/start/quickstart.html">Quick Start</a></li>
		<!-- /start/download.html || /news/2015/11/16/wicket-6.21.0-released.html -->
    	<li class=""><a href="/start/download.html">Download</a></li>
		<!-- /learn || /news/2015/11/16/wicket-6.21.0-released.html -->
    	<li class=""><a href="/learn">Documentation</a></li>
		<!-- /help || /news/2015/11/16/wicket-6.21.0-released.html -->
    	<li class=""><a href="/help">Support</a></li>
		<!-- /contribute || /news/2015/11/16/wicket-6.21.0-released.html -->
    	<li class=""><a href="/contribute">Contribute</a></li>
		<!-- /community || /news/2015/11/16/wicket-6.21.0-released.html -->
    	<li class=""><a href="/community">Community</a></li>
		<!-- /apache || /news/2015/11/16/wicket-6.21.0-released.html -->
    	<li class=""><a href="/apache">Apache</a></li>
    </ul>
</nav>
        <div class="logo">
    <a href="/"><img src="/img/logo-apachewicket.svg" alt="Apache Wicket"></a>
</div>
    </div>
</div>
<main>
    <div class="l-container">
        <header class="l-full preamble">
            <h1>Apache Wicket 6.21.0 released</h1>
        </header>
        <section class="left">
            <div class="l-full">
    <p class="meta">16 Nov 2015</p>
    <p>The Apache Wicket PMC is proud to announce Apache Wicket 6.21.0!</p>
<p>This release marks another minor release of Wicket 6. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present breaks are present in this release compared to
6.0.0.</p>
<h3 id="using-this-release">Using this release</h3>
<p>With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):</p>
<figure class="highlight"><pre><code class="language-xml" data-lang="xml"><span class="nt">&lt;dependency&gt;</span>
<span class="nt">&lt;groupId&gt;</span>org.apache.wicket<span class="nt">&lt;/groupId&gt;</span>
<span class="nt">&lt;artifactId&gt;</span>wicket-core<span class="nt">&lt;/artifactId&gt;</span>
<span class="nt">&lt;version&gt;</span>6.21.0<span class="nt">&lt;/version&gt;</span>
<span class="nt">&lt;/dependency&gt;</span></code></pre></figure>
<p>Or download and build the distribution yourself, or use our
convenience binary package</p>
<ul>
  <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/6.21.0">6.21.0 source download</a></li>
  <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/6.21.0/binaries">6.21.0 binary download</a></li>
</ul>
<h3 id="upgrading-from-earlier-versions">Upgrading from earlier versions</h3>
<p>If you upgrade from 6.y.z this release is a drop in replacement. If
you come from a version prior to 6.0.0, please read our Wicket 6
migration guide found at</p>
<ul>
  <li><a href="https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+6.0">migration to Wicket 6</a></li>
</ul>
<p>Have fun!</p>
<p>— The Wicket team</p>
<h3 id="this-release">This release</h3>
<h4 id="changelog-for-6210">CHANGELOG for 6.21.0:</h4>
<p>The following changes were made in Wicket for this release.</p>
<h4 id="bug">Bug</h4>
<ul>
  <li>[WICKET-5882] - AutoComplete suggestion list disappear when I click on autoComplete scrollbar in IE</li>
  <li>[WICKET-5898] - StackOverflowError after form submit with a validation error</li>
  <li>[WICKET-5925] - wicket-examples DataTablePage is broken</li>
  <li>[WICKET-5927] - Velocity remote code execution</li>
  <li>[WICKET-5939] - AjaxEventBehavior should not lower-case the event name</li>
  <li>[WICKET-5941] - Headers not rendered for components inside TransparentWebMarkupContainer on ajax update</li>
  <li>[WICKET-5944] - CSRF prevention does not work with https URLs on the default port</li>
  <li>[WICKET-5946] - JavaScript/Css PackageResource should use the same charset for compressing</li>
  <li>[WICKET-5959] - HTML input placeholder text breaks AutoCompleteTextField in IE11</li>
  <li>[WICKET-5960] - Page header isn’t rendered for pages where URL has changed during render</li>
  <li>[WICKET-5968] - CachingResourceLocator lookup key doesn’t take strict into account</li>
  <li>[WICKET-5970] - UrlRenderer does not render fragments</li>
  <li>[WICKET-5973] - IllegalArgumentException ‘bytes’ cannot be negative. on opening Inspector</li>
  <li>[WICKET-5978] - LazyInitProxyFactory fills permgen space</li>
  <li>[WICKET-5989] - BaseWicketTester##startComponentInPage fails for pages with <wicket:header-items>&lt;/wicket:header&gt; placeholder</wicket:header-items></li>
  <li>[WICKET-5994] - Mounted TemplateResourceReference throws org.apache.wicket.WicketRuntimeException when https is used</li>
  <li>[WICKET-5996] - Mounted packages throw IllegalArgumentException when visiting base package url.</li>
  <li>[WICKET-6005] - WicketRuntimeException from AjaxPagingNavigator##onAjaxEvent</li>
</ul>
<h4 id="improvement">Improvement</h4>
<ul>
  <li>[WICKET-5926] - Arquillian Support with Container ServletContext in BaseWicketTester/WicketTester.</li>
  <li>[WICKET-5930] - Upgrade Atmosphere to 2.2.7</li>
  <li>[WICKET-5932] - Allow empty column list for DataTable</li>
  <li>[WICKET-5933] - Avoid serialization of untouched page after ajax request</li>
  <li>[WICKET-5935] - IoC Guice: cache proxies and fail on creation when binding is missing</li>
  <li>[WICKET-5945] - add a new topic/listener that notifies of Ajax calls done</li>
  <li>[WICKET-5948] - wicket-ajax.js probably doesn’t traverse the children of &lt;div&gt; or <span></span></li>
  <li>[WICKET-5955] - error from WebPage ## reportMissingHead</li>
  <li>[WICKET-5974] - Change AjaxPagingNavigator##onAjaxEvent() to only consider parent components that have setOutputMarkupId(true)</li>
  <li>[WICKET-5976] - Improve the documentation of FeedbackMessages first(int level)</li>
  <li>[WICKET-5986] - <code class="language-plaintext highlighter-rouge">NumberTextField&lt;N&gt;</code> should use Models for minimum, maximum and step</li>
</ul>
<h4 id="task">Task</h4>
<ul>
  <li>[WICKET-5951] - Upgrade Atmosphere to 2.2.8</li>
</ul>
</div>
        </section>
    </div>
</main>
        <footer>
            <div class="l-container">
    <div class="left">
        <img src="/img/asf_logo_url.svg" style="height:90px; float:left; margin-right:10px;">
        <div style="margin-top:12px;">Copyright © 2020 — The Apache Software Foundation. Apache Wicket, Wicket, Apache, the Apache feather logo, and the Apache Wicket project logo are trademarks of The Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.</div>
    </div>
</div>
        </footer>
    </body>

</html>
