0

I hava a JFrame containing a table with row and column headers. My table is a custom component made of 3 panels (row header, column header and grid). The panels are regular JPanels, containing either JButton or JLabel, in a MigLayout. I display this component inside a JScrollPane in order to scroll simultaneously my grid and my headers. This part works fine.

Now, the user should be able to zoom on my component.

I tried to use the pbjar JXLayer but if I put my whole JScrollPane inside the layer, everything is zoomed, event the scrollbars.

I tried to use 3 JXLayers, one for each viewPort of my JScrollPane. But this solution just mess up with my layout as the panels inside the viewPorts get centered instead of being top-left aligned.

import org.jdesktop.jxlayer.JXLayer;
import org.pbjar.jxlayer.demo.TransformUtils;
import org.pbjar.jxlayer.plaf.ext.transform.DefaultTransformModel;

public class Matrix extends JScrollPane {

    private Grid grid;
    private Header rowHeader; 
    private Header columnHeader; 

    private DefaultTransformModel zoomTransformModel;
    private double zoom = 1;

    public Matrix() {
        super(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

        this.zoomTransformModel1 = new DefaultTransformModel();
        this.zoomTransformModel1.setScaleToPreferredSize(true);
        this.zoomTransformModel1.setScale(1);
        this.zoomTransformModel2 = new DefaultTransformModel();
        this.zoomTransformModel2.setScaleToPreferredSize(true);
        this.zoomTransformModel2.setScale(1);
        this.zoomTransformModel3 = new DefaultTransformModel();
        this.zoomTransformModel3.setScaleToPreferredSize(true);
        this.zoomTransformModel3.setScale(1);

        this.grid = new Grid();

        this.setViewportView(TransformUtils.createTransformJXLayer(this.grid,
                zoomTransformModel1););
        this.matrixRowHeader = new Header(Orientation.VERTICAL);
        this.setRowHeader(new JViewport(
                TransformUtils.createTransformJXLayer(
                    this.rowHeader, zoomTransformModel2)));

        this.matrixColumnHeader = new Header(Orientation.HORIZONTAL);
        this.setColumnHeader(new JViewport(
                TransformUtils.createTransformJXLayer(
                    this.columnHeader, zoomTransformModel2)));
    }

    public void setScale(double scale) {
        this.zoomTransformModel1.setScale(scale);
        this.zoomTransformModel2.setScale(scale);
        this.zoomTransformModel3.setScale(scale);
    }
}

How could I handle the zoom on my JScrollPane without zooming on the scrollBars and without messing up my layout?

jhamon
  • 3,603
  • 4
  • 26
  • 37

1 Answers1

0

First, MigLayout seems to be incompatible with the JXLayer. When using both, the components in the panel using the MigLayout have a unpredictable behaviour.

Then, the original pbjar JXLayer only allows you to put your component in the center of the Layer pane. Pbjar sources can be download on github. Note this is not the official Piet Blok repository.

The solution I found is to modify the TransformLayout, TransformUI, and the TranformModel classes:

Alignment enum give the possible alignment for the component in the layer.

public enum Alignment {
    TOP,
    BOTTOM,
    LEFT, 
    RIGHT,
    CENTER
}

In TransformLayout :

@Override
public void layoutContainer(Container parent) {
    JXLayer<?> layer = (JXLayer<?>) parent;
    LayerUI<?> layerUI = layer.getUI();
    if (layerUI instanceof CustomTransformUI) {
        JComponent view = (JComponent) layer.getView();
        JComponent glassPane = layer.getGlassPane();
        if (view != null) {
        Rectangle innerArea = new Rectangle();
        SwingUtilities.calculateInnerArea(layer, innerArea);
        view.setSize(view.getPreferredSize());
        Rectangle viewRect = new Rectangle(0, 0, view.getWidth(), view
            .getHeight());
        int x;
        int y;
        Alignment alignX = ((CustomTransformUI) layerUI).getAlignX();
        Alignment alignY = ((CustomTransformUI) layerUI).getAlignY();
        if(alignX == Alignment.LEFT) {
            x = (int) (innerArea.getX() - viewRect.getX());
        } else if(alignX == Alignment.RIGHT) {
            x = (int) (innerArea.getX()+innerArea.getWidth()-viewRect.getWidth()-viewRect.getX());
        } else {
            x = (int) Math.round(innerArea.getCenterX()
                    - viewRect.getCenterX());
        }
        if(alignY == Alignment.TOP) {
            y = (int) (innerArea.getY() - viewRect.getY());
        } else if(alignY == Alignment.BOTTOM) {
            y = (int) (innerArea.getY()+innerArea.getHeight()-viewRect.getHeight()-viewRect.getY());
        } else {
            y = (int) Math.round(innerArea.getCenterY()
                    - viewRect.getCenterY());
        }
        viewRect.translate(x, y);
        view.setBounds(viewRect);

        }
        if (glassPane != null) {
        glassPane.setLocation(0, 0);
        glassPane.setSize(layer.getWidth(), layer.getHeight());
        }
        return;
    }
    super.layoutContainer(parent);
}

In TransformUI :

private Alignment alignX; // horizontal alignment
private Alignment alignY; // verticalalignment

public TransformUI(TransformModel model, Alignment alignX, Alignment alignY) {
    super();
    this.setModel(model);
    this.alignX = alignX;
    this.alignY = alignY;
}

public Alignment getAlignX() {
    return alignX;
}

public Alignment getAlignY() {
    return alignY;
}

In TransformModel:

private Alignment alignX = Alignment.CENTER;
private Alignment alignY = Alignment.CENTER;

public CustomTransformModel(Alignment alignX, Alignment alignY) {
    super();
    this.alignX = alignX;
    this.alignY = alignY;
}

@Override
public AffineTransform getTransform(JXLayer<? extends JComponent> layer) {
    JComponent view = (JComponent)layer.getView();
    /*
    * Set the current actual program values in addition to the user
    * options.
    */
    this.setValue(Type.LayerWidth, layer == null ? 0 : layer.getWidth());
    this.setValue(Type.LayerHeight, layer == null ? 0 : layer.getHeight());
    this.setValue(Type.ViewWidth, view == null ? 0 : view.getWidth());
    this.setValue(Type.ViewHeight, view == null ? 0 : view.getHeight());
    /*
    * If any change to previous values, recompute the transform.
    */
    if (!Arrays.equals(this.prevValues, this.values)) {
        System.arraycopy(this.values, 0, this.prevValues, 0, this.values.length);
        this.transform.setToIdentity();
        if (view != null) {
            double scaleX;
            double scaleY;
            double centerX;
            if(this.alignX == Alignment.LEFT) {
                centerX = 0.0;
            } else if (this.alignX == Alignment.RIGHT){
                centerX = layer == null ? 0.0 : (double)layer.getWidth();
            } else {
                centerX = layer == null ? 0.0 : (double)layer.getWidth() / 2.0;
            }
            double centerY;
            if(this.alignY == Alignment.TOP) {
                centerY = 0.0;
            } else if(this.alignY == Alignment.BOTTOM){
                centerY = layer == null ? 0.0 : (double)layer.getHeight();
            } else {
                centerY = layer == null ? 0.0 : (double)layer.getHeight() / 2.0;
            }
            AffineTransform nonScaledTransform = this.transformNoScale(centerX, centerY);
            if (((Boolean)this.getValue(Type.ScaleToPreferredSize)).booleanValue()) {
                scaleY = scaleX = ((Double)this.getValue(Type.PreferredScale)).doubleValue();
            } else {
                Area area = new Area(new Rectangle2D.Double(0.0, 0.0, view.getWidth(), view.getHeight()));
                area.transform(nonScaledTransform);
                Rectangle2D bounds = area.getBounds2D();
                scaleX = layer == null ? 0.0 : (double)layer.getWidth() / bounds.getWidth();
                scaleY = layer == null ? 0.0 : (double)layer.getHeight() / bounds.getHeight();
                if (((Boolean)this.getValue(Type.PreserveAspectRatio)).booleanValue()) {
                    scaleY = scaleX = Math.min(scaleX, scaleY);
                }
            }
            this.transform.translate(centerX, centerY);
            this.transform.scale((Boolean)this.getValue(Type.Mirror) != false ? - scaleX : scaleX, scaleY);
            this.transform.translate(- centerX, - centerY);
            this.transform.concatenate(nonScaledTransform);
        }
    }
    return this.transform;
}

You can now create a zoomable panel with configurable alignment using:

TransformModel model = new TransformModel(Alignment.LEFT, Alignment.TOP);
TransformUI ui = new TransformUI(model, Alignment.LEFT, Alignment.TOP);
new JXLayer((Component)component, (LayerUI)ui)

Note that's a quick fix. It can probably be improved.

jhamon
  • 3,603
  • 4
  • 26
  • 37