<!doctype html><html lang="en"><head><meta charset="utf-8"><meta http-equiv="CACHE-CONTROL" content="NO-CACHE"><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>Apache Royale Blog</title><link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"><link rel="stylesheet" href="/css/styles.css"><link rel="shortcut icon" href="/img/favicon.ico"></head><body class="page post" id="main"><header class="docs-header"><div class="container"><div class="topbar"><div class="topbar-left"><a href="/"><span class="site-title">Apache Royale</span></a></div><div class="topbar-center"></div><div class="topbar-right"><button class="topMenu-dropbtn"><i class="fa fa-bars"></i>&nbsp;Menu</button><ul class="topMenu"><li><a href="/features">Features</a></li><li><a href="https://apache.github.io/royale-docs/get-started">Get Started</a></li><li><a href="/download">Download</a></li><li><a href="/docs">Docs</a></li><li><a href="/blog">Blog</a></li><li><a href="https://github.com/apache/royale-asjs/wiki/Apache-Royale-Source-Code-Repositories"><i class="fa fa-github"></i> GitHub</a></li></ul></div></div><div class="post-header"><h1>Apache Royale Blog</h1><div class="post-meta"></div></div></div></header><div class="page-content"><div class="container"><article><h2 class="post-title"><a href="/blog/apache-royale-v0-9-9-released/">Apache Royale v0.9.9 released!</a></h2><div class="post-meta">by Yishay Weiss on March 30, 2022</div><div><p>The Apache Royale community is pleased to announce the release of <strong>Apache Royale 0.9.9</strong>.</p><p>The Apache Royale project is the next generation of the Apache Flex SDK. It lets developers use <strong>MXML</strong> and <strong>ActionScript 3</strong> to generate <strong>HTML/JS/CSS</strong> applications which can run natively in browsers. The cross-compiled code can also run on platforms like <strong>Electron</strong> or <strong>Apache Cordova</strong> (Adobe PhoneGap) to build mobile applications.</p><p>This release should be considered 'beta' quality, although <em>we're very close to a 1.0 release</em> and <em>we have many applications in production</em> at this point. The purpose of this release is to continue to gather feedback about Royale's features and the project's implementation strategies, and to recruit new contributors. We hope to grow the code base into an SDK and tool chain that delivers the highest productivity when developing applications that can run on many platforms. Beta releases, however, may not handle all production needs.</p><h2>Changes in 0.9.9:</h2><h3>Apache Royale Framework 0.9.9</h3><ul><li>MXRoyale<ul><li>MXRoyale has been split 2 libs : MXRoyaleBase (mostly non-UI code) and MXRoyale (mostly UI code). Users of MXRoyale should see no immediate changes as the build of this swc remains the same.</li><li>Listen to children's resize events to fix some layout issues</li><li>Various fixes to measured sizes (ComboBox, and other UI components)</li><li>Fixes to labels in item renderers not displaying correctly</li><li>ComboBox prompt fixes</li><li>ArrayCollection.refresh() updating lists</li><li>Various fixes to labels in item renderers not showing correctly</li><li>Add option to add custom header renderers to data grids</li><li>Fix issues with Menu.show() when receiving non-null parent arguments</li><li>Improve emulation of ADG's expand/collapse behavior</li></ul></li><li>SparkRoyale<ul><li>ComboBox sizing improvements</li></ul></li><li>Basic<ul><li>Improvements to DragBead's out of bounds behavior</li></ul></li><li>RoyaleUnit<ul><li>Fix coercion error in MetadataRunner when expecting an exception in a test, like [Test(expected=&quot;RangeError&quot;)]</li></ul></li><li>Reflection<ul><li>getQualifiedSuperclassName() can find the superclass of a Class object in JS, matching the behavior of SWF</li></ul></li><li>Examples<ul><li>Ace example running in Maven</li><li>Added Jewel TriStateCheckBox example in <a href="https://royale.apache.org/tourdejewel/">Tour De Jewel</a></li></ul></li><li>Jewel<ul><li>Improved:<ul><li>Added emphasized and secondary sass settings for Jewel CheckBox / Switch</li></ul></li><li>New:<ul><li>Added Jewel TriStateCheckBox and some associated beads: TriStateCheckBoxTooltipState, TriStateCheckBoxState</li><li>Added ComboBoxReadOnly bead</li></ul></li></ul></li><li>Icons<ul><li>Icon constants have been added to MaterialIconType and FontAwesome5IconType</li></ul></li><li>Dozens of bugs reported, investigated, and squashed. For details of closed bug reports see <a href="https://github.com/apache/royale-asjs/issues?q=is%3Aissue+is%3Aclosed">GitHub Issues list</a>.</li></ul><h3>Apache Royale Compiler 0.9.9</h3><ul><li><strong>asformat</strong> is a new command line code formatter for ActionScript and MXML, with a programmatic API for use in editors and IDEs.</li><li>Added a boolean new compiler option <code>compiler.mxml.force-local-id</code> - (short commandline form <code>force-local-id</code>). This is a quick way to avoid propagating id attributes to browser DOM in JSRoyale.</li><li>(JS) Added new string compiler options <code>js-getter-prefix</code> and <code>js-setter-prefix</code> to optionally specify different prefixes to use instead of 'get_' and 'set_' for accessors in the generated JavaScript. Useful for integrating with JS libraries/languages that use a different naming convention.</li><li>(JS) Fix for <code>@royalesuppressexport</code> feature which had stopped working</li><li>(JS) Fix for <code>mx.managers.SystemManager</code> subclass not being generated for applications that were not direct subclasses of the relevant application classes.</li><li>(JS) Improvement in output of locale properties files as ResourceBundles. Now using original Flex/SWF parsing approach for improved parity.</li><li>(JS) First implementation of multiple-catch support in Javascript</li><li>(JS) Added unsafe option for outputting literal javascript (via externally defined jsUnsafeNativeInline function)</li><li>Fixed <code>&lt;!----&gt;</code> in MXML being incorrectly detected as an unclosed ASDoc comment, instead of an empty regular comment.</li><li>(JS) Improved the generated JavaScript for <code>if</code>, <code>else if</code>, and <code>else</code> statements that contained only a semicolon and no braces.</li><li>(JS) Generated JavaScript for <code>parseInt()</code> passes <code>0</code> instead of <code>undefined</code> for radix argument to avoid number format exception.</li><li>(JS) Fixed several issues with generated JavaScript for E4X expressions when using <code>js-dynamic-access-unknown-members</code> compiler option.</li><li>(JS) Fixed a couple of issues with generated JavaScript when using custom namespaces.</li><li>Fixed missing <code>[Event]</code> metadata in playerglobal.swc classes generated from documentation.</li><li>Fixed parse exception when binding to XML.</li></ul><p>For additional information on recent issues that have been closed, see <a href="https://github.com/apache/royale-compiler/issues?q=is%3Aissue+is%3Aclosed">Github Issues List</a></p><p>You can download a <a href="https://royale.apache.org/download/">binary distribution</a>, the <a href="https://royale.apache.org/source-code/">source code</a> or browse our <a href="https://github.com/apache/royale-asjs/wiki/Apache-Royale-Source-Code-Repositories">GitHub repositories</a>. If you're a NPM user you can check <a href="https://www.npmjs.com/org/apache-royale">Apache Royale at NPM</a>.</p><p>As well, you can help us <a href="https://github.com/apache/royale-asjs/issues">filing bug reports for issues you encounter in the framework</a> or <a href="https://github.com/apache/royale-compiler/issues">compiler</a>.</p><p>For questions about how to use Royale, send email to <a href="users@royale.apache.org">mailto:users@royale.apache.org</a>. For questions and feedback on the development of the source code in the release, send email to <a href="mailto:dev@royale.apache.org">dev@royale.apache.org</a>.</p><p>Enjoy! 🙂</p></div><h2 class="post-title"><a href="/blog/apache-royale-v0-9-8-released/">Apache Royale v0.9.8 released!</a></h2><div class="post-meta">by Yishay Weiss on September 02, 2021</div><div><p>The Apache Royale community is pleased to announce the release of <strong>Apache Royale 0.9.8</strong>.</p><p>The Apache Royale project is the next generation of the Apache Flex SDK. It lets developers use <strong>MXML</strong> and <strong>ActionScript 3</strong> to generate <strong>HTML/JS/CSS</strong> applications which can run natively in browsers. The cross-compiled code can also run on platforms like <strong>Electron</strong> or <strong>Apache Cordova</strong> (Adobe PhoneGap) to build mobile applications.</p><p>This release should be considered 'beta' quality, although <em>we're very close to a 1.0 release</em> and <em>we have many applications in production</em> at this point. The purpose of this release is to continue to gather feedback about Royale's features and the project's implementation strategies, and to recruit new contributors. We hope to grow the code base into an SDK and tool chain that delivers the highest productivity when developing applications that can run on many platforms. Beta releases, however, may not handle all production needs.</p><h2>Changes in 0.9.8:</h2><h3>Apache Royale Framework 0.9.8</h3><ul><li>Core<ul><li>Added getClassStyle function that get an Object with all styles in a CSS className.</li></ul></li><li>Basic<ul><li>Move getParentEventTarget() from EventDispatcher to UIBase to reduce require dependencies. This allows EventDispatcher to be used in non-GUI contexts, such as Node.js.</li><li>UIBase, added loadBeads hook method</li><li>Added BrowserResizeListener bead that listen for browser resizing and resizes a component accordingly. Old one was renamed to &quot;BrowserResizeApplicationListener&quot;</li><li>StyledUIBase &amp; ClassSelectorListSupport, added replaceClass method</li><li>Added ILabelFunction and LabelFunction bead</li><li>Added LayoutChildren: A bead to trigger layout in children. Added support in StyledLayoutBase.</li><li>Added interfaces for better extension in Basic and Jewel: IColumns, ITableModel, ITableView, ITextButton, IPaddings, IPositioning</li><li>Paddings: New bead to add padding in mxml to a component</li><li>Positioning: New bead to add positioning in mxml to a component</li><li>Add SelectionDataItemRendererFactoryForCollectionView to handle ISelectionModel for components that uses selection and add/remove/update items at runtime.</li></ul></li><li>RoyaleUnit<ul><li>Fixed issue where CIListener incorrectly escaped quotes in messages.</li><li>Better error messages when <code>[BeforeClass]</code> or <code>[AfterClass]</code> is detected, but method is not found by reflection.</li></ul></li><li>Jewel<ul><li>ASDocs: multiple refactors in many components to document and describe better components</li><li>Item Renderers<ul><li>Refactor to make Basic Layout the default (before was horizontal baked)</li><li>Initializers now use new Paddings bead. Create a default if no one is found.</li><li>Remove then minimum height of 34px, so we can have renderers with less height</li></ul></li><li>New BinaryImage component</li><li>Card:<ul><li>New CardExpandedContent: Used for content that needs to avoid paddings like navigation bars</li></ul></li><li>Button, CheckBox, RadioButton:<ul><li>add &quot;spanLabel&quot; to separate the text from other decorations like icons and get more control over styling</li></ul></li><li>Image added &quot;loadComplete&quot; event<ul><li>New ClipImage bead for images to allow clipping</li><li>New ErrorImage beads</li></ul></li><li>Added SimpleLoader component that show an indeterminate spin circle</li><li>DataContainer<ul><li>dataProvider is now the DefaultProperty</li></ul></li><li>List<ul><li>Added label function through beads</li><li>New ListAlternateRowColor bead (should be temporal until get nth-child css styles work in compiler)</li><li>dataProvider is now the DefaultProperty</li><li>Fixes on SearchFilterForList</li></ul></li><li>ComboBox:<ul><li>Fix Sizing issues</li><li>Improve open popup faster</li><li>new ComboBoxItemByField bead that allows to select an item by field</li><li>dataProvider is now the DefaultProperty</li><li>add item renderer support at mxml (TLC) level</li><li>Fixes on SearchFilter</li></ul></li><li>DateField:<ul><li>Fix Sizing issues</li></ul></li><li>TabBar:<ul><li>Multiple refactors to decouple functionality in beads and make renderers more flexible. Now we allow vertical layouts and indicator in renderer can be positiones in different places</li><li>Add &quot;sameWidths&quot; to make all buttons share the same width.</li><li>dataProvider is now the DefaultProperty</li></ul></li><li>Table<ul><li>Refactor to get better scrolling and fixed header</li><li>Added label function through beads</li><li>New TableAlternateRowColor bead</li><li>Solve RTE when set columns at runtime</li><li>Added Initializer</li><li>New TableAlternateRowColor bead (should be temporal until get nth-child css styles work in compiler)</li><li>Removed CRUD beads and added new CRUDTableItemRendererFactoryForCollectionView</li></ul></li><li>DataGrid<ul><li>Multiple fixes in column dimensions to allow more configurations</li><li>Added sorting through DataGridSortBead</li><li>Added swap of columns</li><li>Added label function through beads</li><li>dataProvider is now the DefaultProperty</li><li>add item renderer support at mxml (TLC) level</li></ul></li><li>PresentationModels refactor for List and DataGrid based controls to allow more flexibility</li><li>NumericStepper:<ul><li>Fix Sizing Issues</li></ul></li><li>New responsive beads: ResponsiveSize, ResponsiveResizeListener and ResponsiveLabelVisibility</li><li>New TileHorizontalLayout and TileVerticalLayout beads</li><li>New ViewLayout for View</li><li>Removed Jewel ControlBar since it was just an HGroup</li><li>Jewel Themes:<ul><li>Lots of changes to accommodate the rest of component development and fixes in jewel</li><li>Add fluid text sizing responsiveness, so size of text shrinks or grows depending on device to fit on different screens</li></ul></li><li>Start of VirtualDataGrid component (still has some issues)</li></ul></li><li>Collections<ul><li>ArrayList.length now is bindable</li></ul></li><li>Maven Distribtuon:<ul><li>The distributions built by Maven should now be equivalent to those of the Ant build.</li></ul></li><li>Maven Archetypes:<ul><li>updated royale-simple-application-archetype</li><li>new new royale-jewel-application-archetype</li><li>new new royale-jewel-module-application-archetype</li><li>new new royale-jewel-crux-application-archetype</li></ul></li><li>Dozens of bugs reported, investigated, and squashed. For details of closed bug reports see <a href="https://github.com/apache/royale-asjs/issues?q=is%3Aissue+is%3Aclosed">GitHub Issues list</a>.</li></ul><p>Updates to the <em>RELEASE_NOTES</em> made after this file was packaged into the release artifacts can be found here:</p><p><a href="https://github.com/apache/royale-asjs/wiki/Release-Notes-0.9.8">https://github.com/apache/royale-asjs/wiki/Release-Notes-0.9.8</a></p><h3>Apache Royale Compiler 0.9.8</h3><ul><li>Fixed issue where problems in .mxml files were sometimes duplicated.</li><li>Fixed issue where unrecognized characters in .mxml files were sometimes ignored, and now an error is reported.</li><li>Fixed some missing syntax checks for bindable variables that should have been the same as non-bindable variables. This may produce some new errors that weren't there before (such as duplicate variable names), but they should have been.</li><li>Fixed issue where a type annotation referencing a class with a private constructor was not correctly resolved.</li><li>Improvements/Fixes in Binding support, added support for binding inheritance, similar to Flex.</li><li>(JS) Source map debugging paths of SDK classes are updated to allow breakpoints in the original .as or .mxml files in the SDK when debugging in a browser or IDE.</li><li>(JS) Added source-map-source-root compiler option to optionally customize the source root of source maps.</li><li>(JS) No longer generates @export annotations for exported symbols in debug builds. Exports are smartly generated when creating a release build, and if they are disabled, they will be omitted from framework classes now too. This can help reduce the size of a release build.</li><li>(JS) Fixed issue where compiling a .swc library with another .swc library on the library-path did not copy the required .js files to the new .swc library. Only when a .swc library is added external-library-path should the .js files not get copied.</li><li>(JS) Improved reproducible builds of .swc library files by ensuring that the paths to .js.map source map files are always referenced with forward slash and never backslash. This matches the existing behavior of references to .js files included with .swc libraries.</li><li>(JS) Static getters/setters are not accessed with <code>[&quot;name&quot;]</code> syntax in generated JavaScript anymore, which required them to always be exported, even if the associated export symbols compiler option were disabled.</li><li>(JS) When internal namespace is used in ActionScript, the generated JavaScript adds the @package annotation.</li><li>(JS) Fixed issue where the Language class was not loaded in the correct order when type coersion is required in a static initializer.</li><li>(JS) (Advanced) Added export-internal-symbols and prevent-rename-internal-symbols compiler options to match the existing options for public and protected namespaces.</li><li>(JS) (Advanced) Added prevent-rename-public-static-methods, prevent-rename-public-instance-methods, prevent-rename-public-static-variables, prevent-rename-public-instance-variables, prevent-rename-public-static-accessors, and prevent-rename-public-instance-accessors compiler options to provide more granular control when prevent-rename-public-symbols is true (same for protected and internal namespaces too).</li></ul><p>For additional information on recent issues that have been closed, see <a href="https://github.com/apache/royale-compiler/issues?q=is%3Aissue+is%3Aclosed">Github Issues List</a></p><p>You can download a <a href="https://royale.apache.org/download/">binary distribution</a>, the <a href="https://royale.apache.org/source-code/">source code</a> or browse our <a href="https://github.com/apache/royale-asjs/wiki/Apache-Royale-Source-Code-Repositories">GitHub repositories</a>. If you're a NPM user you can check <a href="https://www.npmjs.com/org/apache-royale">Apache Royale at NPM</a>.</p><p>As well, you can help us <a href="https://github.com/apache/royale-asjs/issues">filing bug reports for issues you encounter in the framework</a> or <a href="https://github.com/apache/royale-compiler/issues">compiler</a>.</p><p>For questions about how to use Royale, send email to <a href="users@royale.apache.org">mailto:users@royale.apache.org</a>. For questions and feedback on the development of the source code in the release, send email to <a href="mailto:dev@royale.apache.org">dev@royale.apache.org</a>.</p><p>Enjoy! 🙂</p></div><h2 class="post-title"><a href="/blog/royale-at-apachecon-2020/">Royale at ApacheCon 2020</a></h2><div class="post-meta">by Andrew Wetmore on October 02, 2020</div><div><p>The Apache Software Foundation (ASF) held its annual convention, ApacheCon, September 29-October 1, 2020. Because of the pandemic, it was an all-virtual conference. Participants logged in and attended keynote speeches, track sessions, and informal hallway meetings from all around the world. The conference had a track in Mandarin, and sessions in Hindi.</p><p><strong>Attendance broke all previous records, with over three thousand people taking part.</strong> Over 80% were attending their first-ever ASF convention.</p><p>There were 27 presentation tracks, the largest number ever for ApacheCon. Apache Royale was among them, with presenters in Pakistan, Spain, and Canada.</p><p>The tracks were:</p><ul><li><p><strong>Hello, Royale!</strong>: A high-level tour of what Apache Royale does, its history, and what it offers to people creating new applications or migrating existing Flex applications before the end of Flash support. (<a href="https://youtu.be/YLt85Nee4ks">Video</a>) (<a href="https://apache.github.io/royale-docs/presentations/HelloRoyale!-ApacheCon2020.pdf">PDF</a>)</p><img src="/img/blog/apache-royale-track-1.png" width="200"></li><li><p><strong>Moving an App from Flex to Royale</strong>: What's involved in migrating a complex, business-critical application from Apache Flex and the Flash platform to Apache Royale. (<a href="https://youtu.be/O5WJ6nRPX40">Video</a>) (<a href="https://apache.github.io/royale-docs/presentations/MovingaFlexAppToRoyale-ApacheCon2020.pdf">PDF</a>)</p><img src="/img/blog/apache-royale-track-2.png" width="200"></li><li><p><strong>Starting from a blank file</strong>: A demonstration of creating a complex application from an empty file, using Royale's existing features and component sets. (<a href="https://youtu.be/E-Fg5V5DxbY">Video</a>) (<a href="https://apache.github.io/royale-docs/presentations/StartingFromABlankFile-ApacheCon2020.pdf">PDF</a>)</p><img src="/img/blog/apache-royale-track-3.png" width="200"></li><li><p><strong>Tour de Jewel</strong>: A review and discussion of the Jewel component set, the most feature-rich of the component sets Royale provides. (<a href="https://youtu.be/9Wdv-ooku3k">Video</a>) (<a href="https://apache.github.io/royale-docs/presentations/TourDeJewel-ApacheCon2020.pdf">PDF</a>)</p><img src="/img/blog/apache-royale-track-4.png" width="200"></li></ul><p>You can <a href="https://apache.github.io/royale-docs/presentations/presentations.html">download</a> and review PDFs of the four presentations or watch the videos of the presentations available on YouTube.</p></div><a class="btn btn-quiet" href="/blog/page/2/">Older Posts <i class="fa fa-arrow-right"></i></a></article></div></div><footer class="footer"><div class="footer-row"><div class="footer-column"><ul class="footer-list"><li class="apacheroyale"><a href="/">Apache Royale</a></li><li><a href="/">Home</a></li><li><a href="/features">Features</a></li><li><a href="/download">Download</a></li><li><a href="/ides">IDEs and Editors</a></li><li><a href="/showcase">Showcase</a></li><li><a href="/blog">Blog</a></li><li><a href="/team">Team</a></li><li><a href="/thanks-to">Thanks To</a></li><li><a href="https://apache.org/logos/#royale"><i class="fa fa-external-link-square"></i> Logos</a></li><li><a href="https://www.apache.org/licenses/"><i class="fa fa-external-link-square"></i> Apache License v2.0</a></li></ul></div><div class="footer-column"><ul class="footer-list"><li class="documentation"><a href="/docs">Documentation</a></li><li><a href="https://apache.github.io/royale-docs/get-started">Get Started</a></li><li><a href="/docs">Docs</a></li><li><a href="/asdoc">API Reference</a></li><li><a href="https://github.com/apache/royale-asjs/wiki"><i class="fa fa-github"></i>Wiki</a></li><li><a href="https://stackoverflow.com/questions/tagged/apache-royale"><i class="fa fa-stack-overflow"></i> StackOverFlow Tag</a></li></ul><ul class="footer-list"><li class="community"><a href="/get-involved">Community</a></li><li><a href="/get-involved">Get Involved</a></li><li><a href="/mailing-lists">Mailing Lists</a></li><li><a href="/faq">FAQ</a></li></ul><ul class="footer-list"><li class="development"><a href="/source-code">Development</a></li><li><a href="https://github.com/apache/royale-asjs/wiki/Apache-Royale-Source-Code-Repositories"><i class="fa fa-github"></i> Github</a></li><li><a href="https://github.com/apache/royale-asjs/issues"><i class="fa fa-github"></i> Issues</a></li><li><a href="/source-code"><i class="fa fa-code"></i> Source Code</a></li></ul></div><div class="footer-column"><ul class="footer-list"><li class="social_t">Social</li><li><a href="https://twitter.com/apacheroyale"><i class="fa fa-twitter"></i> Twitter</a></li><li><a href="https://facebook.com/ApacheRoyaleSDK/"><i class="fa fa-facebook"></i> Facebook</a></li><li><a href="https://www.linkedin.com/groups/12118437"><i class="fa fa-linkedin"></i> LinkedIn</a></li><li><a href="/feed/index.xml"><i class="fa fa-rss"></i> RSS</a></li></ul><ul class="footer-list"><li class="apache"><a href="https://www.apache.org/">Apache</a></li><li><a href="https://www.apache.org/"><i class="fa fa-external-link-square"></i> Apache</a></li><li><a href="https://www.apache.org/foundation/contributing.html"><i class="fa fa-external-link-square"></i> Donations</a></li><li><a href="https://www.apache.org/events/current-event"><i class="fa fa-external-link-square"></i> Events</a></li><li><a href="https://www.apache.org/foundation/sponsorship.html"><i class="fa fa-external-link-square"></i> Sponsorship</a></li><li><a href="https://www.apache.org/foundation/thanks.html"><i class="fa fa-external-link-square"></i> Thanks</a></li><li><a href="https://www.apache.org/security/"><i class="fa fa-external-link-square"></i>Security</a></li></ul></div><div class="aboutusdiv"><p class="aboutus">About Us</p><p class="aboutus_p"><img class="aboutus-logo" src="/img/apache-royale-logo-footer-circle-grey.svg"><a href="/" class="aboutus_a">Apache Royale™</a> is a highly productive open source application technology for building expressive frontend applications that outputs to different formats and deploy consistently on all major browsers, desktops and devices.</p><p><img class="aboutus-apache-logo" src="/img/Apache_PoweredBy.svg"> <a href="/" class="aboutus_a">Apache Royale™</a>, <a href="https://www.apache.org" class="aboutus_a">Apache™</a> and the <a href="https://www.apache.org/foundation/press/kit/" class="aboutus_a">Apache feather logo™</a> are trademarks of The Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners. Read more about our privacy policy on our <a href="/privacy-policy">Privacy Policy page</a>.</p></div></div><div class="asf">Copyright &copy; 2017-2022 <a href="https://www.apache.org">The Apache Software Foundation</a>, Licensed under the <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a></div></footer></body></html>