java.awt drawRect() wrongly interprets "width" and "height" (produces +1 pixel right and down) - swing

Question

I have started exercising with Swing programming and found one really weird thing which I consider as a bug in the basics.
The below example shows that "width" and "height" values are treated differently when we create a Rectangle and when we display it.
import java.awt.*;
// I create a rectangle 2 x 2 with height=2, width=2
Rectangle rec = new Rectangle(1, 1, 2, 2);
// I make sure that it contains only 4 points: (1,1), (1,2), (2,1), (2,2)
println("- " + rec.contains(1, 1) + ", " + rec.contains(1, 2) + ", " + rec.contains(1, 3));
println("- " + rec.contains(2, 1) + ", " + rec.contains(2, 2) + ", " + rec.contains(2, 3));
println("- " + rec.contains(3, 1) + ", " + rec.contains(3, 2) + ", " + rec.contains(3, 3));
Output:
true, true, false
true, true, false
false, false, false
Then:
// I make sure again that the right-bottom point of my rectangle is (2,2)
// by checking the intersection result with another Rectangle
println("intersect (2,2): " + rec.intersects(new Rectangle(2, 2, 5, 5)));
println("intersect (3,3): " + rec.intersects(new Rectangle(3, 3, 5, 5)));
Output:
intersect (2,2): true
intersect (3,3): false
So from math point of view this is really rectangle 2 x 2 which has 4 integer points (that is 4 pixels): (1,1), (1,2), (2,1), (2,2). But what if we try to render it?
// Let's check what is get drawn
g.drawRect(1, 1, 2, 2); // displays 3 x 3 (as if width=3, height=3) !!
// Try it different way
((Graphics2D)g).draw(rec); // displays 3 x 3 again (as if width=3, height=3) !!
The yellow small rectangle is shown as 3 x 3:
Conclusion: Rectangle() class constructor considers width/height as a real width/height of the shape in pixels, while drawing method drawRect() consider width/height as a shift relative to the left-top pixel.
So java.awt represents the same rectangle as N x M for calculations, but as (N+1) x (M+1) when it is rendered with drawRect().
I find this totally wrong, because the default human logic is to suppose that we draw exactly what we have!
I wonder if someone else knows about this issue and can give some references to bug trackers or/and some logical explanations of such behavior. Just Google search gives me nothing about.
I wonder also how another programmers solve this problem. Use wrappers to drawRect pushing (x, y, width - 1, height -1)? I just can't believe that it is OK for everyone that it is working so weird like this.
UPDATE 1: Posting the "minimal" code snippet which reproduces the problem:
import javax.swing.*;
import java.awt.*;
public class Main {
public static void main(String args[]) {
JFrame jFrame = new JFrame("Bug of drawRect() demo");
JPanel jPanel = new JPanel() {
#Override
public void paintComponent(Graphics g) {
g.drawRect(1,1,2,2);
}
};
jFrame.add(jPanel);
jFrame.setSize(400, 100);
jFrame.setLocationRelativeTo(null);
jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jFrame.setVisible(true);
}
}
UPDATE 2: I am using OpenJDK 8 from https://github.com/ojdkbuild/ojdkbuild/releases. If I use "Go To -> Implementation(s)" in my IDE I see the drawRect() implementation here: C:\Program Files\ojdkbuild\java-1.8.0-openjdk-1.8.0.181-1\src.zip!\java\awt\Graphics.java.
public void drawRect(int x, int y, int width, int height) {
if ((width < 0) || (height < 0)) {
return;
}
if (height == 0 || width == 0) {
drawLine(x, y, x + width, y + height);
} else {
drawLine(x, y, x + width - 1, y);
drawLine(x + width, y, x + width, y + height - 1);
drawLine(x + width, y + height, x + 1, y + height);
drawLine(x, y + height, x, y + 1);
}
}
In this implementation I see that it draws the second and the third line at "x + width" instead of "x + width - 1" which causes the bug.

Answer 1

As I ran into the same problem, with the code below (it is more complex than that), it took me some time to understand what I was doing wrong (I put emphasis here, like you, I think the API is wrong: you draw rectangle of 100x100, it should result in 100x100, not 101x101.):
public class MyComponent extends JComponent {
#Override
public void paintComponent(final Graphics g) {
g.setColor(Color.BLACK);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(Color.RED);
g.fillRect(0, 0, 100, getHeight());
g.setColor(Color.WHITE);
g.drawRect(0, 0, 100, 100);
}
public static void main(final String[] args) {
final JFrame frame = new JFrame("Test");
frame.setSize(150, +156);
frame.getContentPane().add(new MyComponent());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}
This result in the sample window, where we can see the drawn rectangle having one additional pixels on width/height.
This is problematic in my case, because I am calling repaint with the region in which I'm drawing the rectangle. So:
I am calling repaint(0, 0, 100, 100)
Swing repaint the 100x100 square
The white line is still there because it was not repaint.
The problem is that the Graphic class is not homogeneous in how it use the width and height, as one can see in the below Javadoc extract:
From drawRect javadoc:
Draws the outline of the specified rectangle. The left and right edges
of the rectangle are at x and x + width. The top and bottom edges are
at y and y + height. The rectangle is drawn using the graphics
context's current color.
From fillRect javadoc:
Fills the specified rectangle. The left and right edges of the
rectangle are at x and x + width - 1. The top and bottom edges are at
y and y + height - 1. The resulting rectangle covers an area width
pixels wide by height pixels tall. The rectangle is filled using the
graphics context's current color.
Fixing such an API is hard because code depending on it would fail (because to fix the actual problem with code above, I would pass 99x99 to have 100x100 rectangle: fixing the API would result in a 99x99 rectangle).
You may expect this to never be fixed unless the class is retrofitted into a new package (probably merging Graphics2D along the way).
TL;DR: you should probably create a static method drawRect doing the same as fillRect, like below:
public static void drawRect(Graphics g, int x, int y, int w, int h) {
g.drawRect(x, y, w - 1, h - 1);
}