Java Code Examples for java.awt.geom.AffineTransform#equals()

synchronized void setGraphicsConfigInfo(AffineTransform at,
                                        double pw, double ph) {
    Point2D.Double pt = new Point2D.Double(pw, ph);
    at.transform(pt, pt);

    if (pgConfig == null ||
        defaultDeviceTransform == null ||
        !at.equals(defaultDeviceTransform) ||
        deviceWidth != (int)pt.getX() ||
        deviceHeight != (int)pt.getY()) {

            deviceWidth = (int)pt.getX();
            deviceHeight = (int)pt.getY();
            defaultDeviceTransform = at;
            pgConfig = null;
    }
}
 

void emitTransform(AffineTransform transform) {

            if (transform != null && transform.equals(mTransform) == false) {
                double[] matrix = new double[6];
                transform.getMatrix(matrix);
                mPSStream.println("[" + (float)matrix[0]
                                  + " " + (float)matrix[1]
                                  + " " + (float)matrix[2]
                                  + " " + (float)matrix[3]
                                  + " " + (float)matrix[4]
                                  + " " + (float)matrix[5]
                                  + "] concat");

                mTransform = transform;
            }
        }
 

public static void main(final String[] args) {
    final GraphicsEnvironment ge =
            GraphicsEnvironment.getLocalGraphicsEnvironment();
    final GraphicsConfiguration gc =
            ge.getDefaultScreenDevice().getDefaultConfiguration();
    final VolatileImage vi = gc.createCompatibleVolatileImage(200, 200);
    final SunGraphics2D sg2d = (SunGraphics2D) vi.createGraphics();

    sg2d.constrain(0, 61, 100, 100);
    final AffineTransform expected = sg2d.cloneTransform();
    sg2d.setTransform(sg2d.getTransform());
    final AffineTransform actual = sg2d.cloneTransform();
    sg2d.dispose();
    vi.flush();
    if (!expected.equals(actual)) {
        System.out.println("Expected = " + expected);
        System.out.println("Actual = " + actual);
        throw new RuntimeException("Wrong transform");
    }
}
 

synchronized void setGraphicsConfigInfo(AffineTransform at,
                                        double pw, double ph) {
    Point2D.Double pt = new Point2D.Double(pw, ph);
    at.transform(pt, pt);

    if (pgConfig == null ||
        defaultDeviceTransform == null ||
        !at.equals(defaultDeviceTransform) ||
        deviceWidth != (int)pt.getX() ||
        deviceHeight != (int)pt.getY()) {

            deviceWidth = (int)pt.getX();
            deviceHeight = (int)pt.getY();
            defaultDeviceTransform = at;
            pgConfig = null;
    }
}
 

void emitTransform(AffineTransform transform) {

            if (transform != null && transform.equals(mTransform) == false) {
                double[] matrix = new double[6];
                transform.getMatrix(matrix);
                mPSStream.println("[" + (float)matrix[0]
                                  + " " + (float)matrix[1]
                                  + " " + (float)matrix[2]
                                  + " " + (float)matrix[3]
                                  + " " + (float)matrix[4]
                                  + " " + (float)matrix[5]
                                  + "] concat");

                mTransform = transform;
            }
        }
 

public static void main(final String[] args) {
    final GraphicsEnvironment ge =
            GraphicsEnvironment.getLocalGraphicsEnvironment();
    final GraphicsConfiguration gc =
            ge.getDefaultScreenDevice().getDefaultConfiguration();
    final VolatileImage vi = gc.createCompatibleVolatileImage(200, 200);
    final SunGraphics2D sg2d = (SunGraphics2D) vi.createGraphics();

    sg2d.constrain(0, 61, 100, 100);
    final AffineTransform expected = sg2d.cloneTransform();
    sg2d.setTransform(sg2d.getTransform());
    final AffineTransform actual = sg2d.cloneTransform();
    sg2d.dispose();
    vi.flush();
    if (!expected.equals(actual)) {
        System.out.println("Expected = " + expected);
        System.out.println("Actual = " + actual);
        throw new RuntimeException("Wrong transform");
    }
}
 

synchronized void setGraphicsConfigInfo(AffineTransform at,
                                        double pw, double ph) {
    Point2D.Double pt = new Point2D.Double(pw, ph);
    at.transform(pt, pt);

    if (pgConfig == null ||
        defaultDeviceTransform == null ||
        !at.equals(defaultDeviceTransform) ||
        deviceWidth != (int)pt.getX() ||
        deviceHeight != (int)pt.getY()) {

            deviceWidth = (int)pt.getX();
            deviceHeight = (int)pt.getY();
            defaultDeviceTransform = at;
            pgConfig = null;
    }
}
 

public static void main(final String[] args) {
    final GraphicsEnvironment ge =
            GraphicsEnvironment.getLocalGraphicsEnvironment();
    final GraphicsConfiguration gc =
            ge.getDefaultScreenDevice().getDefaultConfiguration();
    final VolatileImage vi = gc.createCompatibleVolatileImage(200, 200);
    final SunGraphics2D sg2d = (SunGraphics2D) vi.createGraphics();

    sg2d.constrain(0, 61, 100, 100);
    final AffineTransform expected = sg2d.cloneTransform();
    sg2d.setTransform(sg2d.getTransform());
    final AffineTransform actual = sg2d.cloneTransform();
    sg2d.dispose();
    vi.flush();
    if (!expected.equals(actual)) {
        System.out.println("Expected = " + expected);
        System.out.println("Actual = " + actual);
        throw new RuntimeException("Wrong transform");
    }
}
 

synchronized void setGraphicsConfigInfo(AffineTransform at,
                                        double pw, double ph) {
    Point2D.Double pt = new Point2D.Double(pw, ph);
    at.transform(pt, pt);

    if (pgConfig == null ||
        defaultDeviceTransform == null ||
        !at.equals(defaultDeviceTransform) ||
        deviceWidth != (int)pt.getX() ||
        deviceHeight != (int)pt.getY()) {

            deviceWidth = (int)pt.getX();
            deviceHeight = (int)pt.getY();
            defaultDeviceTransform = at;
            pgConfig = null;
    }
}
 

void emitTransform(AffineTransform transform) {

            if (transform != null && transform.equals(mTransform) == false) {
                double[] matrix = new double[6];
                transform.getMatrix(matrix);
                mPSStream.println("[" + (float)matrix[0]
                                  + " " + (float)matrix[1]
                                  + " " + (float)matrix[2]
                                  + " " + (float)matrix[3]
                                  + " " + (float)matrix[4]
                                  + " " + (float)matrix[5]
                                  + "] concat");

                mTransform = transform;
            }
        }
 

public static void main(final String[] args) {
    final GraphicsEnvironment ge =
            GraphicsEnvironment.getLocalGraphicsEnvironment();
    final GraphicsConfiguration gc =
            ge.getDefaultScreenDevice().getDefaultConfiguration();
    final VolatileImage vi = gc.createCompatibleVolatileImage(200, 200);
    final SunGraphics2D sg2d = (SunGraphics2D) vi.createGraphics();

    sg2d.constrain(0, 61, 100, 100);
    final AffineTransform expected = sg2d.cloneTransform();
    sg2d.setTransform(sg2d.getTransform());
    final AffineTransform actual = sg2d.cloneTransform();
    sg2d.dispose();
    vi.flush();
    if (!expected.equals(actual)) {
        System.out.println("Expected = " + expected);
        System.out.println("Actual = " + actual);
        throw new RuntimeException("Wrong transform");
    }
}
 

public static void main(final String[] args) {
    final GraphicsEnvironment ge =
            GraphicsEnvironment.getLocalGraphicsEnvironment();
    final GraphicsConfiguration gc =
            ge.getDefaultScreenDevice().getDefaultConfiguration();
    final VolatileImage vi = gc.createCompatibleVolatileImage(200, 200);
    final SunGraphics2D sg2d = (SunGraphics2D) vi.createGraphics();

    sg2d.constrain(0, 61, 100, 100);
    final AffineTransform expected = sg2d.cloneTransform();
    sg2d.setTransform(sg2d.getTransform());
    final AffineTransform actual = sg2d.cloneTransform();
    sg2d.dispose();
    vi.flush();
    if (!expected.equals(actual)) {
        System.out.println("Expected = " + expected);
        System.out.println("Actual = " + actual);
        throw new RuntimeException("Wrong transform");
    }
}
 

void emitTransform(AffineTransform transform) {

            if (transform != null && transform.equals(mTransform) == false) {
                double[] matrix = new double[6];
                transform.getMatrix(matrix);
                mPSStream.println("[" + (float)matrix[0]
                                  + " " + (float)matrix[1]
                                  + " " + (float)matrix[2]
                                  + " " + (float)matrix[3]
                                  + " " + (float)matrix[4]
                                  + " " + (float)matrix[5]
                                  + "] concat");

                mTransform = transform;
            }
        }
 

public static void main(final String[] args) {
    final GraphicsEnvironment ge =
            GraphicsEnvironment.getLocalGraphicsEnvironment();
    final GraphicsConfiguration gc =
            ge.getDefaultScreenDevice().getDefaultConfiguration();
    final VolatileImage vi = gc.createCompatibleVolatileImage(200, 200);
    final SunGraphics2D sg2d = (SunGraphics2D) vi.createGraphics();

    sg2d.constrain(0, 61, 100, 100);
    final AffineTransform expected = sg2d.cloneTransform();
    sg2d.setTransform(sg2d.getTransform());
    final AffineTransform actual = sg2d.cloneTransform();
    sg2d.dispose();
    vi.flush();
    if (!expected.equals(actual)) {
        System.out.println("Expected = " + expected);
        System.out.println("Actual = " + actual);
        throw new RuntimeException("Wrong transform");
    }
}
 

synchronized void setGraphicsConfigInfo(AffineTransform at,
                                        double pw, double ph) {
    Point2D.Double pt = new Point2D.Double(pw, ph);
    at.transform(pt, pt);

    if (pgConfig == null ||
        defaultDeviceTransform == null ||
        !at.equals(defaultDeviceTransform) ||
        deviceWidth != (int)pt.getX() ||
        deviceHeight != (int)pt.getY()) {

            deviceWidth = (int)pt.getX();
            deviceHeight = (int)pt.getY();
            defaultDeviceTransform = at;
            pgConfig = null;
    }
}
 

public static void main(final String[] args) {
    final GraphicsEnvironment ge =
            GraphicsEnvironment.getLocalGraphicsEnvironment();
    final GraphicsConfiguration gc =
            ge.getDefaultScreenDevice().getDefaultConfiguration();
    final VolatileImage vi = gc.createCompatibleVolatileImage(200, 200);
    final SunGraphics2D sg2d = (SunGraphics2D) vi.createGraphics();

    sg2d.constrain(0, 61, 100, 100);
    final AffineTransform expected = sg2d.cloneTransform();
    sg2d.setTransform(sg2d.getTransform());
    final AffineTransform actual = sg2d.cloneTransform();
    sg2d.dispose();
    vi.flush();
    if (!expected.equals(actual)) {
        System.out.println("Expected = " + expected);
        System.out.println("Actual = " + actual);
        throw new RuntimeException("Wrong transform");
    }
}
 

synchronized void setGraphicsConfigInfo(AffineTransform at,
                                        double pw, double ph) {
    Point2D.Double pt = new Point2D.Double(pw, ph);
    at.transform(pt, pt);

    if (pgConfig == null ||
        defaultDeviceTransform == null ||
        !at.equals(defaultDeviceTransform) ||
        deviceWidth != (int)pt.getX() ||
        deviceHeight != (int)pt.getY()) {

            deviceWidth = (int)pt.getX();
            deviceHeight = (int)pt.getY();
            defaultDeviceTransform = at;
            pgConfig = null;
    }
}
 

/**
 * maximizes the circuit shown
 */
public void fitCircuit() {
    GraphicMinMax gr = new GraphicMinMax();
    getCircuit().drawTo(gr);

    AffineTransform newTrans = new AffineTransform();
    if (gr.getMin() != null && getWidth() != 0 && getHeight() != 0) {
        Vector delta = gr.getMax().sub(gr.getMin());
        int pad = circuitScrollPanel.getBarWidth();
        double sx = ((double) getWidth() - pad) / (delta.x + SIZE * 2);
        double sy = ((double) getHeight() - pad) / (delta.y + SIZE * 2);
        double s = Math.min(sx, sy);


        newTrans.setToScale(s, s);  // set Scaling

        Vector center = gr.getMin().add(gr.getMax()).div(2);
        newTrans.translate(-center.x, -center.y);  // move drawing center to (0,0)

        Vector dif = new Vector(getWidth(), getHeight()).div(2);
        newTrans.translate(dif.x / s, dif.y / s);  // move drawing center to frame center
        isManualScale = false;
    } else {
        isManualScale = true;
    }
    if (!newTrans.equals(transform)) {
        transform = newTrans;
        if (circuitScrollPanel != null)
            circuitScrollPanel.transformChanged(transform);
        graphicHasChanged();
    }
}
 

public boolean isIdentical(final History.Step<?> step) {
	if (step.getClass() != TransformationStep.class) return false;
	final HashMap<Displayable,AffineTransform> m = ((TransformationStep)step).ht;
	// cheap test:
	if (m.size() != this.ht.size()) return false;
	// Check each:
	for (final Map.Entry<Displayable,AffineTransform> e : m.entrySet()) {
		final AffineTransform aff = this.ht.get(e.getKey());
		if (null == aff) return false; // at least one Displayable is missing
		if (!aff.equals(e.getValue())) return false; // at least one Displayable has a different AffineTransform
	}
	return true;
}
 

/**
 * Called from SunGraphicsEnv when there has been a display mode change.
 * Note that we simply invalidate hardware surfaces here; we do not
 * attempt to recreate or re-render them.  This is to avoid threading
 * conflicts with the native toolkit and associated threads.  Instead,
 * we just nullify the old surface data object and wait for a future
 * method in the rendering process to recreate the surface.
 */
public void displayChanged() {
    lostSurface = true;
    if (sdAccel != null) {
        // First, nullify the software surface.  This guards against
        // using a SurfaceData that was created in a different
        // display mode.
        sdBackup = null;
        // Now, invalidate the old hardware-based SurfaceData
        // Note that getBackupSurface may set sdAccel to null so we have to invalidate it before
        SurfaceData oldData = sdAccel;
        sdAccel = null;
        oldData.invalidate();
        sdCurrent = getBackupSurface();
    }
    // Update graphicsConfig for the vImg in case it changed due to
    // this display change event
    vImg.updateGraphicsConfig();

    // Compare the Graphics configuration transforms to determine
    // whether the software backed surface needs to be invalidated.
    AffineTransform atUpdated = vImg.getGraphicsConfig()
                                    .getDefaultTransform();
    if (!isAccelerationEnabled()) {
        if (!atUpdated.equals(atCurrent)) {
            // Ideally there is no need to re-create a software surface.
            // But some OSs allow changes to display state at runtime. Such
            // a provision would cause mismatch in graphics configuration of
            // the display and the surface. Hence we re-create the software
            // surface as well.
            sdBackup = null;
            sdCurrent = getBackupSurface();
        } else {
            // Software backed surface was not invalidated.
            lostSurface = false;
        }
    }

    // Update the AffineTransformation backing the volatile image
    atCurrent = atUpdated;
}