weblaf

About

WebLaf is a fully open-source Look and Feel and component library written in pure Java for cross-platform desktop Swing applications. But it is also more than just that - it was made with intention of covering pretty much all aspects of UI development and at this point WebLaF includes an extensive set of features that goes beyond just Look and Feel or Swing component library.

To look at some features provided by WebLaF I recommend checking out the demo -

It is an executable JAR which you can run if you have JRE 6 or higher installed.

Features

• Fully reskinnable UI with a few predefined skins available out-of-the-box
• Wide range of popular custom components and features
• Advanced versions of all basic Swing components
• RTL orientation support for basic Swing and custom components
• Multi-language support for all UI elements
• Advanced API for providing UI element tooltips
• Advanced API for saving and restoring UI element states
• Advanced API for assigning hotkeys to UI elements and actions
• Countless utilities for convenient work with Swing APIs
• Application plugin support
• And more...

WebLaF project

• Fully open-source without any hidden proprietary code
• Have been developed for 10+ years
• Constantly growing and being improved
• Open for any suggestions and improvements

Quick start

Including WebLaF in your project (Maven)

If you are working with a Maven project you can simply add dependency for weblaf-ui module:

<dependency>
  <groupId>com.weblookandfeel</groupId>
  <artifactId>weblaf-ui</artifactId>
  <version>1.2.14</version>
</dependency>

You can also use RELEASE or LATEST version instead of specific one.

Including WebLaF in your project (binaries)

You can always find latest WebLaF binaries in releases section. These are the very same binaries that are available through Maven, simply copied over to release section for convenience. Don't forget to download all dependencies in this case as well, they are always linked at the end of release notes.

If you aren't sure which binaries to use or which dependencies you might be missing - I recommend reading How to use WebLaF wiki article - it gives a short explanation on what each module does and requires.

Installing L&F

You can install WebLaF by simply calling WebLookAndFeel.install () or using one of standard Swing UIManager methods:

public class QuickStart
{
    public static void main ( final String[] args )
    {
        // You should always work with UI inside Event Dispatch Thread (EDT)
        // That includes installing L&F, creating any Swing components etc.
        SwingUtilities.invokeLater ( new Runnable ()
        {
            @Override
            public void run ()
            {
                // Install WebLaF as application LaF
                WebLookAndFeel.install ();

                // You can also specify preferred skin right-away
                // WebLookAndFeel.install ( WebDarkSkin.class );

                // You can also do that in one of the old-fashioned ways
                // UIManager.setLookAndFeel ( new WebLookAndFeel () );
                // UIManager.setLookAndFeel ( "com.alee.laf.WebLookAndFeel" );
                // UIManager.setLookAndFeel ( WebLookAndFeel.class.getCanonicalName () );

                // You can also configure other WebLaF managers as you like now
                // StyleManager
                // SettingsManager
                // LanguageManager
                // ...

                // Initialize your application once you're done setting everything up  
                // JFrame frame = ...

                // You can also use Web* components to get access to some extended WebLaF features
                // WebFrame frame = ...
            }
        } );
    }
}

That's it, now your application is using WebLaF.

Helpful articles

If you are new to Swing I recommend reading official Oracle articles about it first:

• Creating a GUI with JFC/Swing

It is also important to understand how threading should be approached when working with Swing:

• Event Dispatch Thread

And if are new to WebLaF - I recommend checkin out these wiki articles first:

• How to use WebLaF
• Styling introduction

You can also check other wiki articles - there are quite a few available for different WebLaF components and features and they might save you a lot of time.

Sources

One last thing - I higly recommend having WebLaF sources attached to your IDE project. I'm doing my best to keep it clean and well-documented, so if you are wondering what some method does or how a feature works - peeking into the source code might be the easiest and fastest way to find out.

All of WebLaF source code is fully disclosed and available here on GitHub. Source code for releases is available in releases section and on Maven.

Dependencies

Even though I'm trying to keep the minimal amount of dependencies on 3rd-party libraries - WebLaF has quite a few at this point, so it is worth explaining which dependencies are used for what.

First, here are direct library dependencies you may find across different WebLaF modules:

• Slf4j is one of the most commonly used logging tools and also offers nice options for bridging logging over to other popular tools, so this was the obvious choice. Originally I used older log4j verson, but moved on from it due to some restrictions and nuances.

• XStream is used for serializing and deserializing objects to and from XML. LanguageManager uses it to read translation files. SetingsManager uses it to store and read various settings. StyleManager uses it to read skins and skin extensions. IconManager uses it to read icon sets. PluginManager uses it to read plugin descriptors found in plugin JAR file. It is also used for variety of smaller features across WebLaF library.

• SVG Salamander is a standalone library providing loading, modification and rendering capabilities for SVG icons. Unlike Apache Batik it is way more lightweight and often able to render SVG icons slightly faster. It does have a few issues and I plan to make an abstract API for SVG icons support to allow choice between SVG Salamander and Apache Batkin in the future as explained in #337. It is also important to note that currently I'm using my own release of SVG Salamander fork that contains latest changes from original project and some minor non-API-breaking improvements added on top of it.

• Java Image Scaling is a lightweight library used in ImageUtils exclusively for better downscaling of raster images in runtime.

• Jericho HTML parser is used in HtmlUtils for rendering HTML into plain text. It is also used for quick tag lookup in StyleEditor. Potentially I might move this dependency as well as StyleEditor into a separate module(s) as described in #336.

There are also a few code pieces borrowed from other open-source projects:

• TableLayout implementation is based on Clearthought source code, but has some minor modifications and fixes added on top of it.

• Various image filters and utilities found in com.alee.graphics.filters as well as strokes found in com.alee.graphics.strokes packages are based on JH Labs examples, but slightly cleaned up and with a few minor improvements added.

• Easing interface implementations are based on jQuery Easing Plugin source code, but ported to Java and adjusted to better fit into custom animation system implemeted in WebLaF.

• IOUtils implementation is based on Apache Commons IO source code, but since it only uses a fraction of it's functionality I didn't want to include it as dependency.

• Classes backing GifIcon implementation were originally made available by Kevin Weiner at http://www.fmsware.com/stuff/gif.html, which states that the code "may be freely used for any purpose. Unisys patent restrictions may apply to the LZW portions". Unisys and LZW patent enforcement for reference. Code logic was mostly untouched, but I did a refactoring pass and fixed a few possible minor issues.

Other non-code mentions:

• Raster icons are mostly coming from Fugue icon set.

• SVG icons are mostly coming from IconMoon icon set.

It is also important to mention that all dependencies and borrowed code pieces are properly attributed within the library source code itself and within available binary distributions.

Java 9+

Starting from Java 9 once you run an application with WebLaF you will most probably see next warning:

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by com.alee.utils.ReflectUtils (file:weblaf-core-x.x.x.jar) to method {method.name}
WARNING: Please consider reporting this to the maintainers of com.alee.utils.ReflectUtils
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release

Or a similar one pointing at a different JAR or method.

This warning appears because WebLaF uses Reflection API a lot to access various private/proprietary Java featu