There hasn’t been a lot of new content on this blog over the past three weeks, and this entry is just to keep you in sync with what you can expect from the next development drop of the Flamingo component suite.
Here is a partial screenshot of the controls (ribbon, buttons and galleries) under the Metal / Ocean look and feel:
Here is the same component under Windows look and feel in Vista:
And under the Windows Classic look and feel:
What about Nimbus? Here it is:
What about the Looks family? Here it is under Looks Plastic XP:
And how about Synthetica? Here it is under Synthetica Blue Ice
and Synthetica Mauve Metallic:
And here it is under Pagosoft look and feel:
And here it is under Squareness look and feel:
OK, i can go on and on with the screenshots, but you get the point. It can run under any core or third party look-and-feel without any special tricks in the application code and without writing any LAF-specific rendering. Stay tuned for more over the next few days.
It gives me great pleasure to announce the official release for version 4.1 of Substance look-and-feel (code-named Lima). The list of new features includes:
Applications that use or implement custom border painters and title painters should consult the instructions in the migration guide.
In addition to the core release, the following Substance plugins and modules have been updated as well:
The documentation has been updated with the latest visuals and APIs. In addition, there are new tutorials on Substance painters and skinning of custom components.
Special thanks for bug reporting and testing go to Mikael Grev, Vincent Trussart, Kamil Paral, Klaus Rheinwald and Jean-Francois Poilpret.
A few screenshots of the new functionality in Substance 4.1:
The inner border painters and tab pane content borders in the Raven Graphite Glass skin:
The new Creme Coffee skin:
Full support for desktop resolution settings:
Automatic font policy for Gnome desktops:
Here are some Swing links that you might have missed during this week:
- John Zukowski provides an overview of using system tray in JDK 6.0. Judged by the comments, people do not know that you can use JPopupMenu on the system tray icon.
- Alex Potochkin adds yet another useful tool to his SwingHelper project. This entry introduces a “visual debugger” painter that allows seeing what is repainted at runtime, and whether your application / custom components are repainting more than necessary.
- Patrick Lightbody is having some problems with Swing applications (namely IntelliJ IDEA) under Leopard Spaces.
- Daniel Spiewak has written an overview article on Fuse project that allows injecting external resources into custom Swing / Java2D painting code. Based on comments from Daniel and Romain, i am still not convinced that this approach is easier than writing a custom theme for an existing look-and-feel, at least for a big UI that needs consistency for all the visual elements.
- Rafael Alvarez writes about yet another Swing layout manager. You can also read the manual that has more information on the syntax and the usage of the XMLGridLayout. The goal of this layout manager is “to provide all the power of GridBagLayout with the simplicity of an HTML table“.
- Charles Tai has announced the new SwingRCP project. The goal of this project is to provide “a platform for developing applications based on the Eclipse Rich Client Platform (RCP).” This is a commercial product, and it remains to be seen whether it will be able to win the mindshares of either Swing or Eclipse RCP developers.
- An interesting RFE has made its way into the latest binary build of Mustang Update N. RFE 6604856 provides a way to define a RepaintManager for the hierarchy of specified component. I have already discussed the good and the bad sides of RepaintManager as a tool for custom painting, and one of the biggest disadvantages is that RepaintManager is a global resource. It’s not immediately clear where this functionality will be used. My hope is that it was added for internal use in JavaFX (why wait until now? this limitation has been known for a very long time), and not for yet another JavaOne demo. A look at the sources reveals that the implementation is most probably in the new internal com.sun.java.swing.SwingUtilities3 class and its static setDelegateRepaintManager class. Hopefully, this will be formally exposed in Mustang Dolphin to allow using multiple repaint managers in a supported way.
As Substance look-and-feel nears the official release 4.1 (scheduled for November 12th), i’m working on the missing documentation. This entry talks about the using the painter layer to skin custom components.
As mentioned in the painter overview, most of the Substance painting logic is abstracted into a set of painters. This not only allows preventing duplicate painting sequence in the Substance UI delegates. This also provides a painting layer for the applications that wish to paint custom components in a way that is consistent with other Substance visuals.
This applies in two major cases:
- Providing consistent painting for a standalone component suite, such as SwingX.
- Providing consistent painting for custom components and visual areas of a specific application.
Instead of trying to match the colors, gradients and animation sequences from the current Substance skin (which might change between various releases), applications can use the Substance painting APIs. This will result in code which is shorter, more maintainable and also produces consistent results.
Skinning primer
The following Substance APIs are most suited for painting custom components:
Most of the Substance UI delegates use a combination of the above APIs. While the exact combination in the existing UI delegates is subject to change in between releases, you can study the core Substance code to see the main combination patterns.
The first pattern is watermark overlaying. The watermarks are painted on most Swing containers, and on some components as well. In simpler cases (such as <font color="darkblue">JPanel</font>), the watermark is painted on top of the gradient fill. In more complex scenarios, after the watermark has been painted, the fill sequence is repeated with lower alpha value. Here is an example of such a scenario:
In this scenario, while the regular controls and containers on the content pane are painted with the regular watermark, the frame header (title pane and tool bar) has less “intrusive” watermark painting. This is achieved by the following sequence:
- Using the header painter to paint the background gradient.
- Using the watermark to paint the current watermark.
- Using the header painter once again, this time with the
<font color="darkblue">AlphaComposite.SRC_OVER</font> with alpha value of 0.5.
The second pattern is decorating. The header painters can be used to provide distinct painting to some containers, this setting them “apart” from the rest of the application. As the pattern name implies, this works best on specialized containers and visual areas that are situated along the window edges. Here is an example of SwingX <font color="darkblue">JXLoginDialog</font> component painted by the Substance SwingX plugin:
In this scenario, the
<font color="darkblue">JXLoginDialog</font> has a “decoration” strip located along the top side of the window. To paint the background of this component, the custom UI delegate is using the current
header painter, which results in a consistent appearance of the top portion of this dialog.Here is another example of this pattern, this time on the
<font color="darkblue">JXStatusBar</font> component from
SwingX component suite. Assuming that this component will be placed along the bottom side of the frame, the matching UI delegate in the
Substance SwingX plugin uses the current
header painter to provide a distinct appearance of status bar which is consistent with the title pane and menu bar:
The third pattern is
border tracing. Those components that require consistent painting of borders or contours can use the
border painter with the matching contour. Here is an example of border tracing in the
<font color="darkblue">JRibbon</font> component from
Flamingo component suite under the
Substance Flamingo plugin:
This UI delegate uses the
border painter extensively to create the required visuals. Note the outer contour of the ribbon that also includes the selected tab button, and the inner contours of the ribbon tasks.Here is another example of this pattern, this time on the
<font color="darkblue">JCommandButton</font> component from
Flamingo component suite. The custom UI delegate uses the border painter to paint the button border (a simpler contour in this case):
The last pattern is
gradient filling. It is used to paint the inner fill of custom components (along with the border tracing pattern to paint the component contour). This pattern uses the
gradient painter with the matching contour. Here is an example of the
<font color="darkblue">JRibbon</font> component from
Flamingo component suite:
In this example, the first toggle tab button (Write) is filled by the current
gradient painter, providing a consistent appearance with the rest of the application controls. Another example is the previous screenshot (of the
<font color="darkblue">JCommandButton</font>), where the button fill is painted by the current gradient painter as well.
