<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom"> 
    <title>Apache Wicket</title>
    <link href="http://wicket.apache.org/atom.xml" rel="self"/>
    <link href="http://wicket.apache.org/"/>
    <updated>2022-04-08T21:22:45+02:00</updated>
    <id>http://wicket.apache.org/</id>
    <author>
        <name>Apache Wicket</name>
        <email>dev@wicket.apache.org</email>
    </author>
 

    <entry>
        <title>Apache Wicket 9.9.1 released</title>
        <link href="http://wicket.apache.org/news/2022/04/08/wicket-9.9.1-released.html"/>
        <updated>2022-04-08T00:00:00+02:00</updated>
        <id>http://wicket.apache.org/news/2022/04/08/wicket-9.9.1-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 9.9.1!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 9. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 9.0.0.&lt;/p&gt;

&lt;h2 id=&quot;new-and-noteworthy&quot;&gt;New and noteworthy&lt;/h2&gt;

&lt;p&gt;This hotfix reverts WICKET-6963 which causes MarkupException in some particular cases. 
(see https://lists.apache.org/thread/y0zthfw2on04sm9wpn60my3x53b8cb3n).
In addition, this release updates Spring Core dependency to version 5.3.18 which provides a fix 
for Spring4shell vulnerability (CVE-2022-22965).&lt;/p&gt;

&lt;p&gt;NOTE: Wicket is NOT directly impacted by Spring4shell. Your application might be exposed to this 
vulnerability only if you use Spring web frameworks (i.e. Spring MVC and Spring WebFlux).&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;9.9.1&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-9.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 9.y.z this release is a drop in replacement. If
you come from a version prior to 9.0.0, please read our Wicket 9
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket9migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-991&quot;&gt;CHANGELOG for 9.9.1:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6966] - IndexOutOfBounds in InSessionPageStore&lt;/li&gt;
  &lt;li&gt;[WICKET-6965] - Memory leak in WicketEndpoint&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;improvement&quot;&gt;Improvement&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6963] - (REVERTED) Use singletons for PanelMarkupSourcingStrategy&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 9.9.0 released</title>
        <link href="http://wicket.apache.org/news/2022/03/30/wicket-9.9.0-released.html"/>
        <updated>2022-03-30T00:00:00+02:00</updated>
        <id>http://wicket.apache.org/news/2022/03/30/wicket-9.9.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 9.9.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 9. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 9.0.0.&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;9.9.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-9.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 9.y.z this release is a drop in replacement. If
you come from a version prior to 9.0.0, please read our Wicket 9
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket9migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;The signatures for the source release artefacts:
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.9.0.zip:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmJAXfkACgkQh48B+qjT
VuGsxg//YPzI5DOq0ej6p0ntNvYW5uGJUYHGGvUF128f/BQKYBMe3TY3j++ICqGD
kaOJEN412EUcwuDaOMdGhHs7iyFIZvOBZQyfZr/61GssFIrNHCOCtRNM47BeB9/5
kbOyXa4ZN2vDklB132tiVycQYMLEZR3ltYo0SoMSWQNn6hjWNEwEFM6N/ohqFmg6
kgc15ot/qz94z4BswQEUCSNLAWPHQNMv/OgnJFPbHb3a0T0TIqJpVzYso14KmjXv
+RJ1mZe1+AhV5G/2Y0KmzUWWtaybp3PKC1/z9nhJ2+jgrcrbNrPHCSr3w+wN0DuE
H+qU+i2XIhlmzvRE14QTzCk5wyQLKNUGthOIRPWcyE2ISwxPz4tu1YBuA9bg+N0f
ShHzToYt1cvPU32szo0XRFskirrtDBhNp80R1BJbt0QzJXRbSE6C81kBuutr3AT0
YHcq/AJo9QgVFlPMjxaaIht99wORkgxPoxEHIiXmW+GgAwUCcy22En2IjFDq64JR
Pe9FI2V6fsPFqYfaFRXP5ufhttHN1gM8fMvjdoAOf2cgD9JsjzV0vUvYKyFEDd2g
czzSlfRwM2f+NVgZfoUgSWu3vIpnScloTZ3njphHySPuU51q/RdOiYkpU4fj+Dx1
GlvQsZjDpi0SDUjZUKWtg8jCtHCAvWRBWf5LNRkW8Sy1hJPSwms=
=4/qn
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.9.0.tar.gz:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmJAXfkACgkQh48B+qjT
VuEAVhAAks3E8tGn5ah/6IaoZsxkFwdP4XCRM8ae58/YDRsZOqe2DG3+0Lo4RWGE
FDRP8raHsYvVw363fp9+EnaDIO+2E3p0Hk0lpNyr685YOLd7citbpvODUbwj+fNr
hajf4TH57tttjgx1xCOQpuEr1vUUrgeoinlZLlOyUavi8z3N1fcY+nQcYEhrgDI1
k/qA18HVs+1GPuLo2RxvwF2jOej851GIXw3yb7iiFG1mDGW7cz4p6iMoNv6p11/j
wWtWklln4Bg5N84GUhCxwKGIRB49QKNQa4prsuDxmmsTkD4QSYpiFM5Dd1VAal6H
MAUBmJPNa0lt6qfti/y7Fd1CmlDrn3ejPLeihf0hIDbIk3ledGELmOQ9OE60Hvki
Lezj/SylVoh/Nh/YXVl95XxnmZIRJrZSy/XkGwg0rhz6+ZNI9nyVbQDyMcr3hW1H
B3oiiADlF4svXRsNtpNgB1evZ1Tc4EG5d4t03FYamJdL7+GoUr1UTZqTzVNx+1CQ
bnaEJMgZTORxg5LZSpLPSf8zkomkM8KO+MFzzDILt+8oTYJGJaiFOlHVKwyHsOqi
lY7s4rqC2MUZNETJQOU2yPuo8wOXM7w4GV5g+8H1r3I0p6F4tCti0itoY413EBZK
jOF4foag/fAbXmoH8ykV8w+KG55r2TBGeBWiNW3HUamNxkKak+M=
=MK9A
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-990&quot;&gt;CHANGELOG for 9.9.0:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6957] - Declare JSPM ‘uses’ for IInitializer&lt;/li&gt;
  &lt;li&gt;[WICKET-6965] - Memory leak in WicketEndpoint&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;improvement&quot;&gt;Improvement&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6960] - Reduce allocations when encoding ComponentInfo&lt;/li&gt;
  &lt;li&gt;[WICKET-6963] - Use singletons for PanelMarkupSourcingStrategy&lt;/li&gt;
  &lt;li&gt;[WICKET-6964] - Do not allocate when escaping empty string&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 9.8.0 released</title>
        <link href="http://wicket.apache.org/news/2022/02/06/wicket-9.8.0-released.html"/>
        <updated>2022-02-06T00:00:00+01:00</updated>
        <id>http://wicket.apache.org/news/2022/02/06/wicket-9.8.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 9.8.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 9. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 9.0.0.&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;9.8.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-9.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 9.y.z this release is a drop in replacement. If
you come from a version prior to 9.0.0, please read our Wicket 9
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket9migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;The signatures for the source release artefacts:
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.8.0.zip:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmH7144ACgkQh48B+qjT
VuF4Aw/+LHL+jPKVNxCMNdMZksEGuEu5/xFsmkYSOy+8SvNoPqgbkTyTTxtNNhhG
KANFcVXSmfnQrRTZKL86b0YqPaZeViV+C0DFRgfVcINLhPP4mgYXZAiQyerN+9mb
ullo+Dr/O7an/L05ga7v389QxfXChspR8tH057KioLVVuk9CHQLuBqupAoa93+xc
nTtaOzsBzFaTuURS9VW7siGVoSCPhjcIMbU06006U+83xxB6Q0vXD29nLeh3o4SV
pz3qv8cUlU9ap/pOhTjgBHF/F58olvKonOqN0CqCJmOM97Fb1kAT0LTAi8pILyzv
A7jeSWRjEcUddB1J8xrcs0s8L96btg/jKwfb7HXPr51HwwCnerYhMWBvOsWf/fO3
BB2xtKtBTXUPazg3iDqa+oqc/DoWafvMK5PX7r/FlKKXc+N7q4BdNuoK5Ml7D+fB
s83goyoM+q1NxqJ7ogQLm4rJkVVX0bygicuzKYqUWAZGRrOsFxDba7qoVZuciE5d
MrXiW2C2FIonwHp9pEam1bQwNXY53Oz5VsvhBg9W7V8aI3CLnU5CWSV21ncIrBAZ
rndfQe94Q5s7hGadlsHJ+zKcL4dgVhgdMQnkyAcpIHlAwCKSVOhfxq46rVhwdwKB
9JbNtRQqcvDsL8qMhscVu30a2VznkFdr5HVlv1wq1P5bLM954s8=
=rcqn
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.8.0.tar.gz:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmH7144ACgkQh48B+qjT
VuFv7BAArtSt4xkTou5hre9dEkOfBukZA4++4AuoLg5alYw9rn87QEDxkeolr/og
1RAE8HShUTAHJLRDajPPM9u23DLt8OAji6+/SOnY6MBFQ0FMOb7K04gHKVU0/c6r
N9MDJm9YPUiuteiF61oOKt8Y+plcvgyoWio/Bsyrl2aB+VBD/V7RWLwmHLf2qQ4S
sQ81BCMTORbus/3PpM8V+jbZvjIDqTyLsBeObxAMsUWpg1NhzApDeeoEBuoWWO3F
Y5KKNSlv4Ep/NIk7+BhLr8oz08NyVCcFDryk37r1uNpvymG9LA5I2Y/mSmZTN5Rm
S2D7Ct6i9BKsl2YIywjHyk2EoeieiKiDQXs11OBkWbcBWHURXjtNpy8Eg+bWmtSd
De2Uw17IAVINCrHi99UQanHfFybjXGFNCLtAfwYVa1UVnSRaQE/bchRCLtKKhgml
SIATUG+l66RmgJVurrROw0jSP4XGwUyyfbvzZvSxcba41wLv8yZ6diaD6ooX2PcS
Tu3v8BQILkZtKX/t3rUw31Ei3XS/lwjVnfT4fk9cJHXg2KufZbstQVHcUJ5wSeZV
ZmzweHGa+qGWSmAgnVUZYgOO7Ud53dvuAuHg9XTSCJp1tHxTFiJtQoxn1ALiMyaB
1p4Zx8cPBZvM6ruDia32+4cLifMvvL2gHvIOAUdXyXItJC4IWM8=
=qyl3
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-980&quot;&gt;CHANGELOG for 9.8.0:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6944] - Memory leak in WicketEndpoint&lt;/li&gt;
  &lt;li&gt;[WICKET-6945] - MultipartFormComponentListener modifies enctype on invisible forms, leading to javascript errors&lt;/li&gt;
  &lt;li&gt;[WICKET-6947] - IndicatingAjaxButton does not work with Bootstrap 4&lt;/li&gt;
  &lt;li&gt;[WICKET-6953] - JavaScriptDeferHeaderResponse not working correctly for AJAX requests&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;improvement&quot;&gt;Improvement&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6943] - There should be ability to check if current session’s locale is RTL&lt;/li&gt;
  &lt;li&gt;[WICKET-6946] - isVisibleInHierarchy/isEnabledInHierarchy broken by isVisible/isEnabled override&lt;/li&gt;
  &lt;li&gt;[WICKET-6948] - Upgrade Spring to latest 5.3.x&lt;/li&gt;
  &lt;li&gt;[WICKET-6949] - make AjaxDownloadBehavior more dynamic&lt;/li&gt;
  &lt;li&gt;[WICKET-6950] - wicket web-sockets implementation does not allow to configure/access web socket session on onOpen&lt;/li&gt;
  &lt;li&gt;[WICKET-6952] - Performance improvements for Strings.isEmpty&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;task&quot;&gt;Task&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6942] - Replace usage of log4j 1.x in tests and wicket-examples with slf4j-simple&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 8.14.0 released</title>
        <link href="http://wicket.apache.org/news/2022/02/02/wicket-8.14.0-released.html"/>
        <updated>2022-02-02T00:00:00+01:00</updated>
        <id>http://wicket.apache.org/news/2022/02/02/wicket-8.14.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 8.14.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 8. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 8.0.0.&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;8.14.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-8.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 8.y.z this release is a drop in replacement. If
you come from a version prior to 8.0.0, please read our Wicket 8
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket8migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-8140&quot;&gt;CHANGELOG for 8.14.0:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6908] - Possible bug / edge case where page is not detached&lt;/li&gt;
  &lt;li&gt;[WICKET-6910] - StalePageException not thrown&lt;/li&gt;
  &lt;li&gt;[WICKET-6914] - Visibility change of “File Upload” via ajax causes “missing” form-data&lt;/li&gt;
  &lt;li&gt;[WICKET-6931] - User guide: ‘determinate’ is not a verb; should be changed into ‘to determine’&lt;/li&gt;
  &lt;li&gt;[WICKET-6944] - Memory leak in WicketEndpoint&lt;/li&gt;
  &lt;li&gt;[WICKET-6945] - MultipartFormComponentListener modifies enctype on invisible forms, leading to javascript errors&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;task&quot;&gt;Task&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6919] - Improve EnclosureContainer’s javadoc to explain that it should not be used with &lt;wicket:enclosure&gt;&lt;/wicket:enclosure&gt;&lt;/li&gt;
  &lt;li&gt;[WICKET-6937] - Update the keystore used by the quickstart application&lt;/li&gt;
  &lt;li&gt;[WICKET-6942] - Replace usage of log4j 1.x in tests and wicket-examples with slf4j-simple&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 9.7.0 released</title>
        <link href="http://wicket.apache.org/news/2021/12/01/wicket-9.7.0-released.html"/>
        <updated>2021-12-01T00:00:00+01:00</updated>
        <id>http://wicket.apache.org/news/2021/12/01/wicket-9.7.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 9.7.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 9. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 9.0.0.&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;9.7.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-9.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 9.y.z this release is a drop in replacement. If
you come from a version prior to 9.0.0, please read our Wicket 9
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket9migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;The signatures for the source release artefacts:
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.7.0.zip:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmGiU18ACgkQh48B+qjT
VuHpdhAAn6C1fRjx0u1h+WNgitYNx4AfeA3+N/0a6Erbx2DUIIT+mlcD923PJvYg
QJo3lbbChP5vQYUYFbMgbe2SgW+nmEYx4IcFwqhFgvcjCswUtk5M4pmFqI8f7Fn8
QRkZcS+pWQXcRL7tE1nUj7TOcgsVu16qPIwSAbxwzKA7TSElgDnffwvwnc9P+TbE
lGOHPiMSZCAcW2CUu3SEq2Ld+LnRGBCKrDbggWqyMX1Uz3tTUKZfTwpgdWQo+mKQ
vHtheh2Btb0HYPPKyhYC5kjoAz09PVfy5/83Cm5c4GPVEZjN95+Zat21htD/VWJY
YfSNSox9RF4q8QFwmd13qSEhJBe5xigLfggO4vZ8xqxvXc98gAE0Eo0Tw1X6L/qm
qStQ52Jf8N4Ov9NRRrL2t6AFfS46ZgICQKbSG9mH5Mbszq5qbB++sq6GYJr1tRl3
JJji7aOf3iFrhob8Esaqoo6ye2yP7tWun7Ur3GoZneI0xeEMYWuD3zFybyThIR05
pMA3HvzRVKGYE8NdWIMT9+Rv+bgizSFRF1nVY/asmQQGpKYnvGpu3Fs/LNw3XH+b
1LHR0lf0aPleEEJ63w/pNS0wu5c9rP908RZ7wVQqwHxSrsxFqlL71W+kMQsNBAlJ
4iAOEo9elMz9Npeh4nb+4uwZ4JAJAI7S0Omad5gP3lf4jq9eTCQ=
=n2hJ
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.7.0.tar.gz:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmGiU18ACgkQh48B+qjT
VuFhoQ/9HXX3NTLTCXPEKQ3WW+x3FJ2qi7DtaqByK7LOa6T5s0F+9GfIdXEAqU00
ZQKg2YEX9szj7gniV6uxdpFuyWDVzzo9zfw87WBmNeSe0b4qB2q7w9qr/2Z61ZYY
LkNnfiknBknSfCTtOeqq7i3KZnmbcjg6MMkKlQVmrcWSRjIsv7XugIISqxY1qDsd
a9Q870K0y6tDQ9xdmZ7PRMLppg4t8HXg0rPGK6Fh/YeHEdp1SNfAR6omhTvWkDhI
GU5+UXcFp4nLeei6Vod/JxKkiKQinsm0hIDpPQJgdZalLFr+VGrc5QoQuHKt+ZRt
ebEqglNsyYBGWlMLBzPchAhtPyI5TSIFDkcA95h8QQHbppq5jlDy6SW2xUc/0EI1
jlqqfwbR+bfZzqzIA799V3r65L/0EeDfsT22HBByuO7wrNA6ld7LyxaXLVGpdonl
Pe1MKhpNHNkhjpo2PseCQvJclAteaoQwx+YkLECUI0aFDvAWrmYtHX30Jq+T/Wgb
OI0vXJMGmmAKiB7Nik7qE1lDkNf3jJUiIxIGpNGTXVrBXuo+T3Y1rNAuFI98ky8m
EzybSQUpabAY6sVXeX6NSjyQmYLjvscfCrcMoouMWDF21mhDZ8bT1QgmQ/Bbh8Gl
s4A+KaDA8E/LHYN+eUq+eZBvQtuGK6xU/Sl0qvNAeHWipb37io8=
=kzR9
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-970&quot;&gt;CHANGELOG for 9.7.0:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6931] - User guide: ‘determinate’ is not a verb; should be changed into ‘to determine’&lt;/li&gt;
  &lt;li&gt;[WICKET-6936] - FilePageStore fails on windows&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;improvement&quot;&gt;Improvement&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6930] - add some web-socket improvements.&lt;/li&gt;
  &lt;li&gt;[WICKET-6933] - Ease use of InSessionPageStore as persistent store&lt;/li&gt;
  &lt;li&gt;[WICKET-6935] - make some datatable related components more reusable&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;task&quot;&gt;Task&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6937] - Update the keystore used by the quickstart application&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 9.6.0 released</title>
        <link href="http://wicket.apache.org/news/2021/11/02/wicket-9.6.0-released.html"/>
        <updated>2021-11-02T00:00:00+01:00</updated>
        <id>http://wicket.apache.org/news/2021/11/02/wicket-9.6.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 9.6.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 9. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 9.0.0.&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;9.6.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-9.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 9.y.z this release is a drop in replacement. If
you come from a version prior to 9.0.0, please read our Wicket 9
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket9migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-960&quot;&gt;CHANGELOG for 9.6.0:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6921] - MultipartFormComponentListener breaks on hidden components&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;improvement&quot;&gt;Improvement&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6920] - Improve the examples to use the browser’s light/dark mode&lt;/li&gt;
  &lt;li&gt;[WICKET-6924] - Allow image/avif in SecurePackageResourceGuard&lt;/li&gt;
  &lt;li&gt;[WICKET-6927] - Get rid of java.security.AccessController&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;task&quot;&gt;Task&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6918] - Add links to latest wicket.xsd to the web site&lt;/li&gt;
  &lt;li&gt;[WICKET-6919] - Improve EnclosureContainer’s javadoc to explain that it should not be used with &lt;wicket:enclosure&gt;&lt;/wicket:enclosure&gt;&lt;/li&gt;
  &lt;li&gt;[WICKET-6925] - Deprecate AbstractWrapModel&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 9.5.0 released</title>
        <link href="http://wicket.apache.org/news/2021/09/12/wicket-9.5.0-released.html"/>
        <updated>2021-09-12T00:00:00+02:00</updated>
        <id>http://wicket.apache.org/news/2021/09/12/wicket-9.5.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 9.5.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 9. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 9.0.0.&lt;/p&gt;

&lt;h2 id=&quot;new-and-noteworthy&quot;&gt;New and noteworthy&lt;/h2&gt;

&lt;p&gt;This release includes the following notable features:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Full support for Java 9+ module system (WICKET-6904)&lt;/li&gt;
  &lt;li&gt;Support of ByteBuddy as java bytecode manipulation library (WICKET-6913).&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;9.5.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-9.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 9.y.z this release is a drop in replacement. If
you come from a version prior to 9.0.0, please read our Wicket 9
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket9migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;The signatures for the source release artefacts:
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.5.0.zip:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmE2XWAACgkQh48B+qjT
VuFQMw//WPSXS00M6SCtFUlIptsBoX2/lsgFTN9w00q3HnvhLPzTAh9Xv/p5ongr
8mRvl27ODGPqD+2AWR3I6NW036/XG8EKSRUoa8+8g1tI3A4ddHrOWf9v19JDpno1
M53/n6WKyDES8yOgvf/lsBrv2qgV7twj5vYUPFQxTjYIcKi1PY1Hgz32J2KELjPb
/FyraEZy9GtTg8rTtYJm5IRkxWRktPsf+/b9dX8deB0XzL9cAz8aeeVs1fudLqGc
jCHRqUh7yiI/U9jvzwuC7jX3BpqHvREORE16om9JDVf1pMSYAolAPllJfhAWvPLE
h3wlU9LVaDP7jpoys2gU2SOfWU56ZX7nTBzsxI4njAz4StQqE0TbwldqwM4ubKR0
gPH9Aw6+vHiSAcaRXXw+jiH4lS5+lA5Di3GzyUIfVLrOYoBbyuF0PXu3Fs7kx8C1
vDBIG1zqYN5XDSDt5QWu5e5yDA9OsKJpf0l8n3/fH0PgF+bShZ6XGO6LZlRX/PqV
IemwK3Q1dopUskkqVwNmMpEkfYA/wNC4oREpxiPhPzncWSmfgZk/UX7+/z0L3tQl
oa0QElb3IxZ/3KYJPycPRQOu+1cNmw1W3NFKmMbVg1T1/Feza1Owy/S/a3giivnZ
nK5Kf1+OzElbNziUUZ35TI+6FJOnlEiPt344gWvgMXl+5Wf1/kI=
=9qdv
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.5.0.tar.gz:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmE2XWAACgkQh48B+qjT
VuG3KRAAk/MwBH7DQ2kR1B0NoxFR3mFArwksVp+2X2NAeV9n4aerN/qL3n38p+xw
qn4+kTSUREi64/2t85Vx5ug6Ub6SZCptljj3PNRJpaWZ4GEptf+et+r1qd2bF7h3
xECcGjvwsSbmrRnwNl3TFhmIh5FR6eNnfnaCqMbvoEuNT/zyPlXhQXFUE1jGDvdR
mK9tZRYU2nO1KZF3msUK0Oo/7FeOgIidY6vCDqQfxofWulXaKUyBZ2h9k6zxf/RR
eH766w4Ir2mIg8Npsv/itIaYRQKJJK8m7StMaczlKEVF+kitmkbfKbQkzjWLyDgB
x0tOmReNOpi8eXAg7hIO156wCBEyapuktDMMBL60OLXV7E/Gpv1JaEWTNhvqzz6a
bFcecacDLKJY4+60szDGnBR8sLqgO3OW+YBEqhDcjXY92iRIr0rKVkUB/QLMOfhS
DqMa7fuJlN4AO6RMOqF5bMB7UUqmTh86C0h0Y0I/GmiBUfwBnoXdEXeIgST0YXuP
+0zUP4A2L2CNoJsfXp2DdL2zEJLvnL5wfTYr/mJTGyhyB5QISbU0L+WlYPgJADQR
FagwMUNfhu1CD/LLtRk4WvtXkKntWv8aR0x/7JpuzeVKmky1qKYD+7N0Tx1KpvC0
ODJZbyYgtBAjLcZ6GELX5GG8dZy27LSzpaI9zvg8IIoFsFbSfpY=
=gYzQ
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-950&quot;&gt;CHANGELOG for 9.5.0:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6884] - Wicket API 9.x refers to 10.0.0-M1-SNAPSHOT API&lt;/li&gt;
  &lt;li&gt;[WICKET-6902] - Change of PartialPageUpdate order of onAfterResponse and writePriorityEvaluations makes IListener.onAfterResponde ignore prepended javascripts&lt;/li&gt;
  &lt;li&gt;[WICKET-6908] - Possible bug / edge case where page is not detached&lt;/li&gt;
  &lt;li&gt;[WICKET-6909] - Link to Javadoc for 9.x is broken on the website&lt;/li&gt;
  &lt;li&gt;[WICKET-6913] - Java 17 compatibility with cglib&lt;/li&gt;
  &lt;li&gt;[WICKET-6914] - Visibility change of “File Upload” via ajax causes “missing” form-data&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;improvement&quot;&gt;Improvement&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6901] - PropertyValidator improve configuration doc&lt;/li&gt;
  &lt;li&gt;[WICKET-6911] - wicket-spring throws an error when a spring bean uses ctor injection&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;task&quot;&gt;Task&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6903] - Replace maven-clirr-plugin with something newer&lt;/li&gt;
  &lt;li&gt;[WICKET-6904] - Make Apache Wicket fully supporting Java9+ module system&lt;/li&gt;
  &lt;li&gt;[WICKET-6916] - Simplify JMX with StandardMBean&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 8.13.0 released</title>
        <link href="http://wicket.apache.org/news/2021/07/13/wicket-8.13.0-released.html"/>
        <updated>2021-07-13T00:00:00+02:00</updated>
        <id>http://wicket.apache.org/news/2021/07/13/wicket-8.13.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 8.13.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 8. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 8.0.0.&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;8.13.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-8.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 8.y.z this release is a drop in replacement. If
you come from a version prior to 8.0.0, please read our Wicket 8
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket8migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;The signatures for the source release artefacts:
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-8.13.0.zip:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmDmFt0ACgkQh48B+qjT
VuFwgRAAgCdSxSBHRyWjkDbftxoCtJkD49s9pKYdcqfZNYa7Nyn4s55/Tn1e869H
NkuX6ilBtExMcljZ2/XKMVG2qfgc5zOQUPt5EnIBdSN0n5vBODsN7aEs0bqv7JFV
b0E4TE0+s+xOM5UVyIFKDVNDZ7Yw9QESgLGJiwVl2tScL6XD7KVVTVmSlQ82iygA
isR1HgDXpiMwUF3SUsTzWqbF3y5E9+B5o3BFduW/C2PHloSgqgQnIel/z1rIxRHR
rfIsmKnF54++U2FTgfVZ7g3JK5/ICVAYp879D1OH7tKCIeExyys0Pf8KTpUEsYzr
WvzuyDWrgpYex5+fOo+MEFZo5gT13ETYfkA2riy1jJMNG3RAZaqJKaeAxXu3omnw
7BXFkgBwthOZugMxsaNzfeg4QlnamM+MHUOvv69H0VqxdNp4Nf20CwkWG4oPBJ1+
pf9ibHTv0yUn3FhN3a3/4RpTYQNd2uEAKkZg+t7FM7GiIZpxS8t2c2QOWWH75o9U
fZh0IZhs/xRZtk8Oz2s/pkkSrIXOAkLeloywzQmayYJ4uDWedKmZprgiNrlLWX+y
jxCzl2Mgyldvq1Wk3wsU4+gHQuy3C7F+Ke46Yq9dSQRudzT+vFnEd05IwygwRRUk
Ah54MiQXKjaZ8sw7ZfEpn+9iSgowH7HE4IVymXUNmakStLPEERg=
=uYXi
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-8.13.0.tar.gz:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmDmFtwACgkQh48B+qjT
VuG/jA/+MMIlUwjB5xeJSOYD8h/gAqRCURMzfhJOvquxQA9p8LuFFMRAONtEY2T6
Q9srMrU5SnHnd9DJljSFZ14SvP4+vLKdBQkCuFdfXAs019GUg27/X2h5NU63jV1e
UK5GvByRgsOoylEtLRa85/a3fxQn0sypnUFQtqimub/JzcZrDpRenJyR+w486Jbc
AdrcmJw7/xxLb3x6gKB6MVW3/wd5igxlL9ClPqJWtLpCedjJUpF/OyW00H4t6D3r
6F5NCLMgpapjnTwXI1BmjWBU/Br8LFMRNuA5HgrEJ3JGw33PYrwaSwgf9Z8Gzd83
OVOmVlZY6KhEsih5FZ7wKPrhTleCN4Y+eKQaGVWlUAz4Q+1UiHF2kD4Ng/pR3goG
lJfeTysNrPXsqh5/uKIoNaaC3eafn1t6ESTRemSmxEIeyI7iWPqs0QeRSb/NKcJn
4iO3JXPgnp4e8WokDzRqukpAxz57IynAVactBOk1D+SBD4Wy4jSpP/sUFmcKYrw/
rUj1XPgFmxYvWTxhHJixEy27VfaPbBEx4qklV5oZ7sF9a9EF3dyTh8uJltnPygdU
OWRx3Q+SOJW4+CMwAN8Vs5nVG2/gkd/BzljWBkQxWKQo2x21yRXU6KDIA3TIzsks
/bNS8oER0AhCnEqv5Ax57toANqssYYbbIpjh7CUHQFJMdXcsOi8=
=1mHV
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-8130&quot;&gt;CHANGELOG for 8.13.0:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6875] - Example for FileSystemResource.java does not work&lt;/li&gt;
  &lt;li&gt;[WICKET-6877] - Removing component’s MetaData during detach phase from within a Behavior causes issue&lt;/li&gt;
  &lt;li&gt;[WICKET-6878] - Rendering of relative Urls does not take into account filterpath for absolute Urls&lt;/li&gt;
  &lt;li&gt;[WICKET-6881] - Link on website to JavaDoc of version 1.3.x is broken&lt;/li&gt;
  &lt;li&gt;[WICKET-6896] - AutoCompleteTextField re-opens dropdown item list after item has been selected&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;new-feature&quot;&gt;New Feature&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6886] - LambdaChoiceRenderer&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;improvement&quot;&gt;Improvement&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6876] - add an AJAX behavior that allows to collect file information when a file, to be uploaded,  is selected.&lt;/li&gt;
  &lt;li&gt;[WICKET-6880] - Documentation of DataTable/DataGridView has reference to unknown class UserProvider&lt;/li&gt;
  &lt;li&gt;[WICKET-6885] - Add scope col and colgroup to HeadersToolbar&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 9.4.0 released</title>
        <link href="http://wicket.apache.org/news/2021/07/07/wicket-9.4.0-released.html"/>
        <updated>2021-07-07T00:00:00+02:00</updated>
        <id>http://wicket.apache.org/news/2021/07/07/wicket-9.4.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 9.4.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 9. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 9.0.0.&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;9.4.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-9.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 9.y.z this release is a drop in replacement. If
you come from a version prior to 9.0.0, please read our Wicket 9
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket9migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;The signatures for the source release artefacts:
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.4.0.zip:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmDgnyEACgkQh48B+qjT
VuHqqRAAgt7YlKtohGggBNLBqgcyMHDSttXyWyPffkd2QaCCx66lWJJl1LxM+87o
LRG5IdaWJWBmB/MJZwXZKV4iacztt/i3nkdIWAw7XrPaWwFLpS6SftfIRvVbrRwD
dVpNFhQe8LmHW2Iun9hhjI6nQWjW2neEvj41T4m5la5JoJ4JBHZ1yZRPUz+rw3Bg
E5j9wYsq3itzuKJQPeMmvVgrbCbBQL8LijIIYmWq/pU+j5wgZ71722Vw6ygGHZJF
MDN2/gnw908ENcjUfMP9e+ZqD2UWzXTWeNqaGAAq4EwLqjjBlxHtIFZ918BTDl72
dzhCndnkTU/4KP9lpBO7h+6s44JwNIIypYsMPaNEQtNAH7OayDjD1uNUkm3vbaGA
uxDg33fYDVCRh/8Hbe8T1YwGIUR2W9U88Mw2yzjzpHv/H7/UVHF9mRmj5sg7Pvsd
G2/SMd9JUW04qb6+zYb4vadNnut7pQEv39bHWZUKTmFt0vNNy7pcGAZk4DmfJRJW
IY5vfLqDyM5QNG/wyzj4NQAIX5y+3iaibzsIRy+bviqLdRf3zsf3fbM23FDmFuDF
nDeD0FK31swaK/9CSYXUXIndoAESbt4iHPCV6TUaare9AgobtIgulvRknr/nFtCB
kuV/8x+8UNsW96YiaLGLW7zjxBiWH8R433fDBG6Pi3f9gpb1cOs=
=kI95
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-9.4.0.tar.gz:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmDgnyAACgkQh48B+qjT
VuFFVw//bAq/Rzxq1ZobgGcgOubDqn1II6y6Un5w6baXEx7MoqEOC8zj/iJz/MEX
+ZyeQDs0W7D5vI+PLi0dcytjDw39zX6XcKTtocQo3jqxztQaRll2ymozNZkk8jZs
z+bq7pA600VUbpfUqpdRvVCLKqahILtvNv7eoHSn6EPIt4zGMcS9vuzY7zFy3P9P
XZnSKSLAEwZ0PWF07rBMl8+ZVP+p98qreJp0WyF0nsxVuOXQde5jys2QvXBPEShY
9FSd1YWZ4fc9hgx7UrgiL9z6gZGDj1yZTTrrnvR3sNgbD4oWSY+oKxM+v6LywrcI
yUfY4qk3onw5YNO8qLGUDh5NVpodnKBm9CMCCI9U3qPP0PkplYvWGH110I+o5er7
yi29J6Fua1dQxKZzxuCQLhZjSItg+QN+qYoukV36pnYqsXJCOwM/S6IUZVT6EPII
gbatn6xECLYsx7gpMmLpysQN0ogNujBJV4I4ZoiARG9xVBWlILdyG4atstvVazf3
u6/yOmkUb+82KV9xsM2sQUJ68cMbAN/aLl578reTZU8fVkS5WoN1laMOumiNbLG0
SX9akYW3huAaLPYRRz7yducTp46fPbwfZ2tlq29iTrGE/uDCOuGwq2XppHahnKt7
8xV9SJ6lK65LzqkPOl8GTMxNjo0afXRQ84paPbhFWyAIRCQlRrM=
=4lVk
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-940&quot;&gt;CHANGELOG for 9.4.0:&lt;/h4&gt;

&lt;h5 id=&quot;bug&quot;&gt;Bug&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6875] - Example for FileSystemResource.java does not work&lt;/li&gt;
  &lt;li&gt;[WICKET-6877] - Removing component’s MetaData during detach phase from within a Behavior causes issue&lt;/li&gt;
  &lt;li&gt;[WICKET-6878] - Rendering of relative Urls does not take into account filterpath for absolute Urls&lt;/li&gt;
  &lt;li&gt;[WICKET-6881] - Link on website to JavaDoc of version 1.3.x is broken&lt;/li&gt;
  &lt;li&gt;[WICKET-6895] - Links to examples in documentation points to old version of 8x&lt;/li&gt;
  &lt;li&gt;[WICKET-6896] - AutoCompleteTextField re-opens dropdown item list after item has been selected&lt;/li&gt;
  &lt;li&gt;[WICKET-6897] - Javadoc build fails on fresh checkout of master or rel/wicket-9.3.0&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;new-feature&quot;&gt;New Feature&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6886] - LambdaChoiceRenderer&lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;improvement&quot;&gt;Improvement&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;[WICKET-6876] - add an AJAX behavior that allows to collect file information when a file, to be uploaded,  is selected.&lt;/li&gt;
  &lt;li&gt;[WICKET-6880] - Documentation of DataTable/DataGridView has reference to unknown class UserProvider&lt;/li&gt;
  &lt;li&gt;[WICKET-6885] - Add scope col and colgroup to HeadersToolbar&lt;/li&gt;
  &lt;li&gt;[WICKET-6899] - Add setExceptionMapperProvider to Application&lt;/li&gt;
&lt;/ul&gt;

</content>
    </entry>

    <entry>
        <title>Apache Wicket 7.18.0 released</title>
        <link href="http://wicket.apache.org/news/2021/04/06/wicket-7.18.0-released.html"/>
        <updated>2021-04-06T00:00:00+02:00</updated>
        <id>http://wicket.apache.org/news/2021/04/06/wicket-7.18.0-released</id>
        <content type="html">&lt;p&gt;The Apache Wicket PMC is proud to announce Apache Wicket 7.18.0!&lt;/p&gt;

&lt;p&gt;Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org&lt;/p&gt;

&lt;p&gt;This release marks another minor release of Wicket 7. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present in this release compared to 7.0.0.&lt;/p&gt;

&lt;h2 id=&quot;using-this-release&quot;&gt;Using this release&lt;/h2&gt;

&lt;p&gt;With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-xml&quot; data-lang=&quot;xml&quot;&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.apache.wicket&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;wicket-core&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;7.18.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Or download and build the distribution yourself, or use our
convenience binary package you can find here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Download: http://wicket.apache.org/start/wicket-7.x.html#manually&lt;/li&gt;
&lt;/ul&gt;

&lt;!--more--&gt;

&lt;h2 id=&quot;upgrading-from-earlier-versions&quot;&gt;Upgrading from earlier versions&lt;/h2&gt;

&lt;p&gt;If you upgrade from 7.y.z this release is a drop in replacement. If
you come from a version prior to 7.0.0, please read our Wicket 7
migration guide found at&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;http://s.apache.org/wicket7migrate&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Have fun!&lt;/p&gt;

&lt;p&gt;— The Wicket team&lt;/p&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;The signatures for the source release artefacts:
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-7.18.0.zip:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmBnhKYACgkQh48B+qjT
VuFrbA/+KUdB3vEBSAE9Kh8dAOqHXl/NYKe0eVvq3tYnLJS8aFZ2C6iF3tRW5XnZ
zMwXrcwoFhFl0tTcAPzaXJuZAaMDuVR5SQ10/VjEhY15X6yjPlj6OLmxlYKj2Wtq
NSgIQfzjTYxEflNRP5yBKap6vH7lo/JgerVeREHswu7f5VzsAJjCZ/r+CxWL4EQ+
gyawjj+x3O0ghK7nmE4iQPQ/QUMRsDY/6ZBx8A7d0oCcKC5WYjv/g6zMJDvBtiON
mVXMbrR4H+EVvssIATesUPj9NSm6YYE/M9KiXYxV1z1FVnzaVsZ/sKcEgpVN3GKY
IropEoBnL0cEBlrvRws1NhYH0cZoaprmJL767lDplTqw1dZSCzPkE+HDyVDXOhRF
L1dQKw9J9rIUO7WntJikIgvFyPnHoqAkQaYRDwA7aAFeiSwmkSZaSdXjNfeo693H
6EVM3nnOnS+s324sPB/0B3EILEC5tNcH6A+JrDNLT424tDv6aKp3bNUiSvWcEia/
i1MZHNwV6vh31t9lCjEAChF7S8Q6sihOZEGLd47taxGxvOapGU+2s3+5o9N1+6Yv
dExZ66YabbDhYjfZEsSyLyVQ3nQUMEmMopX+VesQdyKRRCr341iCubs13idfZIdZ
XfM9CkuNMP7xDL+Q8gkj1P6ntaTDY4gsyw9lftUMy0P3iHZAvfU=
=uFpM
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;Signature for apache-wicket-7.18.0.tar.gz:&lt;/p&gt;

&lt;div class=&quot;highlight&quot;&gt;&lt;pre&gt;
-----BEGIN PGP SIGNATURE-----

iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAmBnhKUACgkQh48B+qjT
VuF/Rg//e7FPfycSb5VyzUdL3xHP+kz6SuU+ysd/C+oru3/+Q3ZYjsibq82k5arV
lOIYbBzmyVUBGCbuc7PFrGKlNk1fYeCA3QGjnYoYQCffsAzwANGGBuYi3Y2priNC
AAnoRmrzI6j8veUmeBu36UjbDFcB4ewXl3ZE2Dwwxjdvm1OK66LZWXns/T2a6jWx
bTpZ5BAHV4h0KtpcvYT+XGf7hAZUoaahlO1yraF7bvL9RgTjJT/wLz5ao5QUQZ5C
HS/V2CqVRHFJ2l6vDBhGNON1gBRsnlJCAnnmnh65Gf0X7U8GYwKAFHES2NX/T6cp
1lc8P7rbAH/Ny/BkZ2Xx1p82Q8cIpFmHoPvBsulVy4GHb6mFNQJg82Fdd6lp9G7e
YVg/m7z131Gvcpnm9eBA52DL/cIQfRHfK4Ukx38xbORUBVkv2fU5hbDErvDL3Hs6
ImcK5FY75xUFhgA4ZdKQERXecahljEMNBNGgs8Zm83jz1peJDdaoSCHTGQfGvo2m
CRvI36Li66qV5XzQis5VzqIoFy0j37Mf/GVdBQVGDeYDsAN7cWK8UzfNRDnH2CBg
eTUcAX3GVooTMjAQHwjEa4BD7MS/vV+IRNyJ2wtHdY1HIXx9fWKpDj2kTNZepwWr
YUVdPzyxuTNxD5Cyes6UGkrdk0OM8LsAxszdzQgNc+u0WpOyoiI=
=nt1w
-----END PGP SIGNATURE-----
&lt;/pre&gt;&lt;/div&gt;

&lt;p&gt;========================================================================&lt;/p&gt;

&lt;h3 id=&quot;this-release&quot;&gt;This Release&lt;/h3&gt;

&lt;h4 id=&quot;changelog-for-7180&quot;&gt;CHANGELOG for 7.18.0:&lt;/h4&gt;

</content>
    </entry>

</feed>
