Synth/Nimbus: how to implement a new UI-delegate?

Question

my first steps in the region - so please be lenient :-)
Problem is that nearly everthing in the Synth package is package private, looks like a completely sealed shop. Even the ui-delegate creation doesn't follow the usual pattern (register the class and let the manager instantiate it later) but is hard-coded - hard to belief, but truely constructors called - in the SynthLookAndFeel. There is no way to extend that I can see.
Actually, the instantiation doesn't hurt us (== SwingX), because our AddOn mechanism takes care of it (and does a good job, fortunately).
what does hurt, afaics, is the fact that the delegates can't be implemented the synth-way: using context, state, region, painter ... many of those are invisible to external classes. It starts with the simple update method, standard in all synth delegates is
    public void update(Graphics g, JComponent c) {
        SynthContext context = getContext(c);
        SynthLookAndFeel.update(context, g); // invisble
        context.getPainter(). // invisible
                  paintListBackground(context,
                          g, 0, 0, c.getWidth(), c.getHeight());
        context.dispose(); // invisible
        paint(g, c);
    } Pretty sure I'm overlooking something obvious ... it can't be that the LAF was designed to not be extensible with new component types, or can it?
Any pointers, hints, examples highly welcome!.
Thanks
Jeanette
BTW: this is a cross-post from the swinglabs forum to get as wide a spread as possible :-) The discussion there is at
[http://forums.java.net/jive/thread.jspa?threadID=65533]

Answer 1

Ok.. so here's my understanding.
Suppose we create a bunch of new SwingX components.
public class XComponent extends JComponent {
    public final static String uiClassId = "XComponentUI";
    public XComponent() {
        updateUI();
    @Override
    public void updateUI() {
        setUI((XComponentUI) UIManager.getUI(this));
    public void setUI(XComponentUI ui) {
        super.setUI(ui);
}Now we need to make sure UIManager.getUI(this) actually works. So...
UIManager.put(XComponent.uiClassID,"blabla.SynthXComponentUI");Now we need to provide SynthXComponentUI.
package blabla;
import java.awt.Graphics;
import javax.swing.JComponent;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.synth.*;
public class SynthXComponentUI extends ComponentUI{
    SynthStyle style;
    SynthStyle leftStyle;
    SynthStyle rightStyle;
    public static ComponentUI createUI(JComponent target) {
        return new SynthXComponentUI();
    @Override
    public void installUI(JComponent c) {
        super.installUI(c);
        style = SynthLookAndFeel.getStyle(c, XRegion.XCOMPONENT);
        leftStyle = SynthLookAndFeel.getStyle(c, XRegion.XCOMPONENT_LEFT);
        rightStyle = SynthLookAndFeel.getStyle(c, XRegion.XCOMPONENT_RIGHT);
    protected SynthContext getContext(JComponent c, Region r, SynthStyle style) {
        int state = 0;
        state |= c.isEnabled()?SynthConstants.ENABLED:SynthConstants.DISABLED;
        state |= c.isFocusOwner()?SynthConstants.FOCUSED:0;
        java.awt.Point mousePoint = c.getMousePosition();
        if(mousePoint != null) {
            if(r == XRegion.XCOMPONENT) {
                state |= SynthConstants.MOUSE_OVER;
            }else if(r == XRegion.XCOMPONENT_LEFT && mousePoint.x < c.getWidth()/2) {
                state |= SynthConstants.MOUSE_OVER;
            }else if(r == XRegion.XCOMPONENT_RIGHT && mousePoint.x > c.getWidth()/2) {
                state |= SynthConstants.MOUSE_OVER;
        return new SynthContext(c,r,style,state);
    @Override
    public void paint(Graphics g, JComponent c) {
        SynthContext context = getContext(c, XRegion.XCOMPONENT, style);
        ((SynthXPainter) style.getPainter(context)).paintXComponentBackground(
                context, g, 0, 0, c.getWidth(), c.getHeight());
        context = getContext(c, XRegion.XCOMPONENT_LEFT, style);
        ((SynthXPainter) leftStyle.getPainter(context)).paintXComponentLeftBackground(
                context, g, 0, 0, c.getWidth()/2,c.getHeight());
        context = getContext(c,XRegion.XCOMPONENT_RIGHT,style);
        ((SynthXPainter) rightStyle.getPainter(context)).paintXComponentLeftBackground(
                context, g,c.getWidth()/2, 0, c.getWidth()/2,c.getHeight());
}Here, I'm pretending the Component is broken into three regions. The whole component itself serves as one region. And then the left and right side of the component serves as subregions. I assume all regions are defined in this class called XRegion.
package blabla;
import javax.swing.plaf.synth.Region;
public class XRegion extends Region{
    public static final XRegion XCOMPONENT = new XRegion("XComponent","XComponentUI", false);
    public static final XRegion XCOMPONENT_LEFT = new XRegion("XComponentLeft",null,true);
    public static final XRegion XCOMPONENT_RIGHT= new XRegion("XComponentRight",null,true);
   //other regions would also be defined
    public XRegion(String name, String ui, boolean subComponent) {
        super(name,ui,subComponent);
}Presumebly, this XRegion class would contain all the new defined regions for your SwingX components.
In my UI, I'm also assuming that the StyleFactory returns a style whose SynthPainter is something called SynthXPainter.
package blabla;
import javax.swing.plaf.synth.SynthPainter;
import javax.swing.plaf.synth.SynthContext;
import java.awt.Graphics;
public class SynthXPainter extends SynthPainter{
    public void paintXComponentBackground(SynthContext context, Graphics g,int x, int y, int w, int h) {}
    public void paintXComponentBorder(SynthContext context, Graphics g, int x, int y, int w, int h) {}
    public void paintXComponentLeftBackground(SynthContext context, Graphics g,int x, int y, int w, int h) {}
    public void paintXComponentRightBackground(SynthContext context, Graphics g,int x, int y, int w, int h) {}
    //other painting methods for SwingX would be defined
}The SynthXPainter class would contain all the new paintXXX methods to paint your SwingX components. Much like SynthPainter does for Swing.
Then there's the SynthContext. In the UI I provided a method called getContext. All it pretty much does is calculate the state of the component and returns a new SynthContext based on that state. The only thing unique about it is that I decided to set the MOUSE_OVER flag only if the the mouse is over the region being painted. With the appropriate SynthContext and SynthXPainter, I can call the methods I need to paint XComponent.
Note that I don't need to call SynthContext#dispose (which is invisible) on the objects I create. This is because the SynthContext is not cached anywhere when using the public api for the class.
Now we need to provide a SynthStyleFactory that returns a SynthStyle appropriate for the regions.
SynthLookAndFeel.setStyleFactory(new SynthStyleFactory() {
   SynthStyleFactory wrapper = SynthLookAndFeel.getStyleFactory();
    @Override
    public SynthStyle getStyle(JComponent c, Region id) {
        if (id instanceof XRegion) {
            if (id == XRegion.XCOMPONENT) {
                return new XStyle(new XComponentPainter());
            } else if (id == XRegion.XCOMPONENT_LEFT) {
                return new XStyle(new XComponentLeftPainter());
            } else if (id == XRegion.XCOMPONENT_RIGHT) {
                return new XStyle(new XComponentRightPainter());
            } else {
                throw new IllegalArgumentException("Unkown region!");
        } else {
            wrapper.getStyle(c, id);
});Where I defined XStyle like so,
package blabla;
import java.awt.Color;
import java.awt.Font;
import javax.swing.plaf.synth.*;
public class XStyle extends SynthStyle{
    private SynthXPainter painter;
    public XStyle(SynthXPainter painter) {
        this.painter = painter;
    @Override
    public SynthPainter getPainter(SynthContext context) {
        return painter;
    @Override
    protected Font getFontForState(SynthContext context) {
        throw new UnsupportedOperationException("Not supported yet.");
    @Override
    protected Color getColorForState(SynthContext context, ColorType type) {
        throw new UnsupportedOperationException("Not supported yet.");
}I didn't actually implement XComponentPainter, XComponentLeftPainter, and XComponentRightPainter. But they would extend SynthXPainter and override the appropriate painting methods.