painting a custom JComponent on a JLayeredPane

[alex schulze]

EDIT: this is an edited version of the original post since that was probably a bit too much at once... i'll try to keep it a bit simpler now to hopefully get an answer...
dear javaranch community,

i have found this place a valueable source of information then and when and finally signed up to discuss an issue i'm not really sure about.
i have the OpenJDK Runtime Environment (build 1.6.0_0-b11) installed, my OS is Ubuntu-Linux.
the scenario is as follows:

i want to display a number of lines and some filled rectangles on a panel. all of these objects can possibly overlap and the z-order (or stacking order) is important.
i found that when i draw onto a normal JPanel, its not entirely reliable that the last painted object is also displayed on top so i found JLayeredPane might be useful for what i am trying to achieve. since i wan't full control over where my lines and rectangles appear, i use a null-layout (no layout-manager).

it took some time until i found out, that my custom JComponents won't get painted unless i call setSize() with values > 0 before.
further, when i set my custom JComponent to lets say a size of 50x50, it seems i can only use draw commands within the area of (0,0) and (50,50), everything outside this area won't get displayed.

so unless line 29 on SimpleLine is commented in, no lines are visible and since there is no output on the console, paintComponent() is probably never called.
:?: can anybody please tell me whats happening here or confirm this behaviour?

here is a code example, the controlling class:

package custJComponentDrawingSimple;

import javax.swing.JFrame;
import javax.swing.JLayeredPane;
import java.awt.Color;

public class CJCD {

	private static JFrame frm;
	private static JLayeredPane lpnl;

	protected static int pnlw, pnlh;		// the inner dimensions of the panel (without windowborders)
	
	public static void main(String[] args) {
		
		// main window settings
		CJCD.frm = new JFrame( "custJComponentDrawingTest" );
		CJCD.frm.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		CJCD.frm.setSize( 400, 400 );
		CJCD.frm.setResizable(false);
		CJCD.frm.setLayout(null);
		CJCD.frm.setVisible( true );

		// determine inner size of window
		CJCD.pnlw = CJCD.frm.getContentPane().getWidth();
		CJCD.pnlh = CJCD.frm.getContentPane().getHeight();
		
		// SimpleLines will be stacked in a layered pane
		CJCD.lpnl = new JLayeredPane();
		// set panes size to main windows inner size
		CJCD.lpnl.setSize( CJCD.pnlw, CJCD.pnlh );
		CJCD.lpnl.setOpaque(true);
		CJCD.lpnl.setBackground(new Color(31, 31, 31));
		CJCD.lpnl.setVisible(true);
		
		CJCD.frm.add(CJCD.lpnl);	// add lpnl to frame

		
		// add some test-lines
		SimpleLine cSL1, cSL2;

		cSL1 = new SimpleLine(1, 10, 10, 360, 360);
		CJCD.lpnl.add(cSL1, 1);
		// this doesn't help
		cSL1.setVisible(true);
		cSL1.repaint();	// explicitly request repaint of the component
		
		cSL2 = new SimpleLine(2, 80, 300, 380 , 10);
		CJCD.lpnl.add(cSL2, 2);
		
		CJCD.lpnl.repaint();		// explicitly request repaint of the container
	}
}

and my JComponent:

package custJComponentDrawingSimple;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.BasicStroke;

import javax.swing.JComponent;

public class SimpleLine extends JComponent {
	
	private int id, xstart, ystart, xend, yend;
	private static Color basecolor = new Color(159, 31, 31, 255);
	private static BasicStroke str = new BasicStroke(2 , BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER);

	// constructor
	public SimpleLine( int id, int xstart, int ystart, int xend, int yend ) {
		this.id = id;
		this.setNewCoords(xstart, ystart, xend, yend);
	}
	
	// the line should get changed through this method
	public void setNewCoords(int xstart, int ystart, int xend, int yend) {
		this.xstart = xstart;
		this.ystart = ystart;
		this.xend = xend;
		this.yend = yend;
		// comment in the line below to make the lines appear
//		this.setSize(Math.max(this.xstart, this.xend), Math.max(this.ystart, this.yend));
	}
	
	@Override
	public void paintComponent(Graphics g) {
        super.paintComponent(g);	
        Graphics2D g2d = (Graphics2D) g;
        g2d.setColor(SimpleLine.basecolor);
        g2d.setStroke(SimpleLine.str);
        g2d.drawLine( this.xstart, this.ystart, this.xend, this.yend );
        System.out.println("SimpleLine #"+this.id+" values are ("
      		  +this.xstart+","+this.ystart+") to ("
      		  +this.xend+","+this.yend+") .");
	}
}

note that both classes are in a package called 'custJComponentDrawingSimple', so to run the code, you'd need to put the two files into a folder named like the package and call 'javac custJComponentDrawingSimple/*.java' to compile and 'java custJComponentDrawingSimple.CJCD' to run the compiled code.

thanks a lot,
alex

[alex schulze]

oh right, i could of course set the size of the component to the visible area of the parent container, but i noticed that this seriously impacts the drawing performance of my application. i guess that is because the whole area is considered as dirty region and redrawn on the next update no matter if necessary or not. and i guess its not quite the way this was meant to be used...

[alex schulze]

well, i finally found the reason why these issues were happening the way i described scattered over some threads on sun-forums:

it has to do with the null-layout manager. with a layout manager, one would use setPreferredSize and set the components size. the layout manager then would determine the display-size according to its rules and call setSize as well as the location and call setLocation on that component.
when java2d finally renders the component it relies on the values set through these methods.

if there is no layout-manager (and this is what null-layout means), the size and location is not set, so the default values of (0,0) for components and (10,10) for JPanels are used!
in this case, calling setPreferredSize() would of course have no effect because there is nobody who takes care of the preferred values.

oh right, note that setBounds( ... ) does the same as calling setSize and setLocation, just within one single call.

[alex schulze]

one more think if ever someone may stumble over this thread trying to do the same:

this was the entirely wrong approach for what i wanted to do and its rendering is far too slow!
i luckily came across a wonderful book that covers plenty java-graphics issues in-depth,
the title sounds not like it would be very helpful but in fact it turned out as a great resource.

the book is called 'filthy rich clients', was written by Chet Haase and Romain Guy
and can be obtained through http://www.filthyrichclients.org/.

my solution in short: don't misuse custom jcomponents as graphical objects put into a jlayeredpanel,
use bufferedImages and draw them to a bufferedimage instead, but make sure to get ito java2d and the like.
(one more time: this book helped me a lot with this!)

greez - alex