AffineTransform translate differnet Graphics Object

Question

I call my draw Classes from this method:

@Override
protected void paintComponent(Graphics g) {

    super.paintComponent(g);
    DrawGradient gradient = new DrawGradient();
    gradient.draw(g);

    DrawCoordinateSystem coor = new DrawCoordinateSystem();
    coor.draw(g);
}

I try to transform the object in the DrawGradient class, but for some reason the Graphics object in class DrawCoordinateSystem gets transformed. Why?

DrawCoordinateSystem class:

public class DrawCoordinateSystem {

public DrawCoordinateSystem() {
    // TODO Auto-generated constructor stub
}

 public void draw(Graphics g1){

             Color customcolor = new Color(210,191,245);

             int x0 = 15, y0 = 15;

             int Xpoints[] = {x0+45, x0+40, x0+40};
             int Ypoints[] = {y0, y0-5, y0+5};

             int Xpoints1[] = {x0, x0+5, x0-5};
             int Ypoints1[] = {y0+45, y0+40, y0+40};


             g1.setColor(customcolor);

             g1.drawPolygon(Xpoints,Ypoints, 3);
             g1.fillPolygon(Xpoints,Ypoints, 3);

             g1.drawPolygon(Xpoints1,Ypoints1, 3);
             g1.fillPolygon(Xpoints1,Ypoints1, 3);

             g1.drawLine(x0, y0, x0+40, y0);
             g1.drawLine(x0, y0, x0, y0+40);

             g1.setFont(new Font("TimesRoman", Font.PLAIN, 12));
             g1.drawString("x", 52, 30);

             g1.setFont(new Font("TimesRoman", Font.PLAIN, 12));
             g1.drawString("y", 23, 57);

    }

}

DrawGradient class:

public class DrawGradient {

public DrawGradient() {

}


private  Color c1;
private  Color c2;


public void draw( Graphics g ) {

        Graphics2D g2d1 = (Graphics2D) g;
        GradientPaint gp = new GradientPaint(0, 0, c2, 0, 100, c1);
        g2d1.setPaint(gp);
        Rectangle reckt = new Rectangle(0,0,100,100);
        g2d1.fill(reckt);

        AffineTransform move = new AffineTransform();
        move.translate(200, 200);
        g2d1.setTransform(move);





}

}

Answer 1

Transformation's are compounding, so, once you apply a transformation, you need to reverse it when you're done.

Now, you can do this manually, or you could just create a copy of the Graphics context before hand and dispose of it when you done. This prevents any changes you make to the properties of the copy to be made to the original (but the what you paint remains)

public class TestPane extends JPanel {

    public TestPane() {
    }

    @Override
    public Dimension getPreferredSize() {
        return new Dimension(200, 200);
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Color c1 = new Color(0, 0, 255);
        Color c2 = new Color(0, 255, 255);
        GradientPaint gp = new GradientPaint(0, 0, c1, 0, 100, c2);

        Graphics2D g2d = (Graphics2D) g.create();
        g2d.setPaint(gp);
        g2d.setTransform(AffineTransform.getTranslateInstance(100, 100));
        g2d.fill(new Rectangle(0, 0, 100, 100));
        g2d.dispose();

        g2d = (Graphics2D) g.create();
        g2d.setPaint(gp);
        g2d.fill(new Rectangle(0, 0, 100, 100));
        g2d.dispose();
    }

}

In your case, I'd be tempered to create a copy of the Graphics context BEFORE you pass it to the other methods, for example

Graphics2D g2d =(Graphics2D)g.create();
DrawGradient gradient = new DrawGradient();
gradient.draw(g2d);
g2d.dispose();

g2d =(Graphics2D)g.create();
DrawCoordinateSystem coor = new DrawCoordinateSystem();
coor.draw(g2d);
g2d.dispose();

This way you can take control. I'd advise against making new objects in the paintComponent method if you can avoid it, especially if those don't really change from one paint cycle to another, as paintComponent can be called a number of times in quick succession