GridBagLayout & Canvas question

Question

I hit a snag during my homework assignment. I am in the making of a RTS game, and want to draw on a Canvas, which I'm placing within a Panel that has a GridbagLayout using the following code:
pane = new Panel(new GridBagLayout());
GridBagConstraints c = new GridBagConstraints();
//pane.add(new Label(), c);
c.gridx = 0;
c.gridy = 0;
c.fill = GridBagConstraints.BOTH;
pane.add(field, c);As I understand this should place and size the field (Canvas) to fill out all the available space in the panel, but all I see is a big white nothing. http://users.hszk.bme.hu/~fm649/javasnag0.png The funny thing is that if I delete the comment tag before
pane.add(new Label(), c);then I actually get what I wanted, the field (Canvas) is drawn correctly in the appropriate place and size (except for the label itself in the center of the window). http://users.hszk.bme.hu/~fm649/javasnag1.png Any ideas why is this happening?
Thanks in advance, Mike

Answer 1

the making of a RTS game, and want to draw on a
Canvas, which I'm placing within a Panel that has aYou want to draw on a canvas? By default canvas is not equiped to do this. If you want a canvas you can draw on, check out my code below. If you are using AWT instead of swing you might have to modify this a little, but it shouldn't be too hard
You are welcome to use and modify this code, but please do not change the package or take credit for it as your own work.
tjacobs.ui.PaintArea.java
====================
* Created on Jun 15, 2005 by @author Tom Jacobs
package tjacobs.ui;
import java.awt.image.BufferedImage;
import java.awt.*;
import java.awt.event.*;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.ImageIcon;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.SwingUtilities;
import tjacobs.MathUtils;
* PaintArea is a component that you can draw in similar to but
* much simpler than the windows paint program.
public class PaintArea extends JComponent {
     BufferedImage mImg; //= new BufferedImage();
     int mBrushSize = 1;
     private boolean mSizeChanged = false;
     private Color mColor1, mColor2;
     static class PaintIcon extends ImageIcon {
          int mSize;
          public PaintIcon(Image im, int size) {
               super(im);
               mSize = size;
     public PaintArea() {
          super();
          setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
          addComponentListener(new CListener());
          MListener ml = new MListener();
          addMouseListener(ml);
          addMouseMotionListener(ml);
          setBackground(Color.WHITE);
          setForeground(Color.BLACK);
     public void paintComponent(Graphics g) {
          if (mSizeChanged) {
               handleResize();
          //g.drawImage(mImg, mImg.getWidth(), mImg.getHeight(), null);
          g.drawImage(mImg, 0, 0, null);
          //super.paintComponent(g);
          //System.out.println("Image = " + mImg);
          //System.out.println("Size: " + mImg.getWidth() + "," + mImg.getHeight());
     public void setBackground(Color c) {
          super.setBackground(c);
          if (mImg != null) {
               Graphics g = mImg.getGraphics();
               g.setColor(c);
               g.fillRect(0, 0, mImg.getWidth(), mImg.getHeight());
               g.dispose();
     public void setColor1(Color c) {
          mColor1 = c;
     public void setColor2(Color c) {
          mColor2 = c;
     public Color getColor1() {
          return mColor1;
     public Color getColor2() {
          return mColor2;
     class ToolBar extends JToolBar {
          ToolBar() {
               final ColorButton fore = new ColorButton();
               fore.setToolTipText("Foreground Color");
               final ColorButton back = new ColorButton();
               back.setToolTipText("Background Color");
               JComboBox brushSize = new JComboBox();
               //super.createImage(1, 1).;
               FontMetrics fm = new FontMetrics(getFont()) {};
               int ht = fm.getHeight();
               int useheight = fm.getHeight() % 2 == 0 ? fm.getHeight() + 1 : fm.getHeight();
               final BufferedImage im1 = new BufferedImage(useheight, useheight, BufferedImage.TYPE_INT_RGB);
               Graphics g = im1.getGraphics();
               g.setColor(Color.WHITE);
               g.fillRect(0, 0, useheight, useheight);
               g.setColor(Color.BLACK);
               g.fillOval(useheight / 2, useheight / 2, 1, 1);
               g.dispose();
               //im1.setRGB(useheight / 2 + 1, useheight / 2 + 1, 0xFFFFFF);
               final BufferedImage im2 = new BufferedImage(useheight, useheight, BufferedImage.TYPE_INT_RGB);
               g = im2.getGraphics();
               g.setColor(Color.WHITE);
               g.fillRect(0, 0, useheight, useheight);
               g.setColor(Color.BLACK);
               g.fillOval(useheight / 2 - 1, useheight / 2 - 1, 3, 3);
               g.dispose();
//               im2.setRGB(useheight / 2 - 1, useheight / 2 - 1, 3, 3, new int[] {     0, 0xFFFFFF, 0,
//                                                            0xFFFFFF, 0xFFFFFFF, 0xFFFFFF,
//                                                            0, 0xFFFFFF, 0}, 0, 1);
               final BufferedImage im3 = new BufferedImage(useheight, useheight, BufferedImage.TYPE_INT_RGB);
               g = im3.getGraphics();
               g.setColor(Color.WHITE);
               g.fillRect(0, 0, useheight, useheight);
               g.setColor(Color.BLACK);
               g.fillOval(useheight / 2 - 2, useheight / 2 - 2, 5, 5);
               g.dispose();
//               im3.setRGB(useheight / 2 - 2, useheight / 2 - 2, 5, 5, new int[] {     0, 0, 0xFFFFFF, 0, 0, 
//                                                            0, 0xFFFFFF, 0xFFFFFFF, 0xFFFFFF, 0,
//                                                            0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF,
//                                                            0, 0xFFFFFF, 0xFFFFFFF, 0xFFFFFF, 0,
//                                                            0, 0, 0xFFFFFF, 0, 0}, 0, 1);
               //JLabel l1 = new JLabel("1 pt", new ImageIcon(im1), JLabel.LEFT);
               //JLabel l2 = new JLabel("3 pt", new ImageIcon(im2), JLabel.LEFT);
               //JLabel l3 = new JLabel("5 pt", new ImageIcon(im3), JLabel.LEFT);
               brushSize.addItem(new PaintIcon(im1, 1));
               brushSize.addItem(new PaintIcon(im2, 3));
               brushSize.addItem(new PaintIcon(im3, 5));
               //brushSize.addItem("Other");
               add(fore);
               add(back);
               add(brushSize);
               PropertyChangeListener pl = new PropertyChangeListener() {
                    public void propertyChange(PropertyChangeEvent ev) {
                         Object src = ev.getSource();
                         if (src != fore && src != back) {
                              return;
                         Color c = (Color) ev.getNewValue();
                         if (ev.getSource() == fore) {
                              mColor1 = c;
                         else {
                              mColor2 = c;
               fore.addPropertyChangeListener("Color", pl);
               back.addPropertyChangeListener("Color", pl);
               fore.changeColor(Color.BLACK);
               back.changeColor(Color.WHITE);
               brushSize.addItemListener(new ItemListener() {
                    public void itemStateChanged(ItemEvent ev) {
                         System.out.println("ItemEvent");
                         if (ev.getID() == ItemEvent.DESELECTED) {
                              return;
                         System.out.println("Selected");
                         Object o = ev.getItem();
                         mBrushSize = ((PaintIcon) o).mSize;
               //Graphics g = im1.getGraphics();
               //g.fillOval(0, 0, 1, 1);
               //BufferedImage im1 = new BufferedImage();
               //BufferedImage im1 = new BufferedImage();
     protected class MListener extends MouseAdapter implements MouseMotionListener {
          Point mLastPoint;
          public void mouseDragged(MouseEvent me) {
               Graphics g = mImg.getGraphics();
               if ((me.getModifiers() & InputEvent.BUTTON1_MASK) != 0) {
                    g.setColor(mColor1);
               } else {
                    g.setColor(mColor2);
               Point p = me.getPoint();
               if (mLastPoint == null) {
                    g.fillOval(p.x - mBrushSize / 2, p.y - mBrushSize / 2, mBrushSize, mBrushSize);
                    //g.drawLine(p.x, p.y, p.x, p.y);
               else {
                    g.drawLine(mLastPoint.x, mLastPoint.y, p.x, p.y);
                    //g.fillOval(p.x - mBrushSize / 2, p.y - mBrushSize / 2, mBrushSize, mBrushSize);
                    double angle = MathUtils.angle(mLastPoint, p);
                    if (angle < 0) {
                         angle += 2 * Math.PI;
                    double distance = MathUtils.distance(mLastPoint, p) * 1.5;
                    if (angle < Math.PI / 4 || angle > 7 * Math.PI / 4 || Math.abs(Math.PI - angle) < Math.PI / 4) {
                         for (int i = 0; i < mBrushSize / 2; i ++) {
                              g.drawLine(mLastPoint.x, mLastPoint.y + i, p.x, p.y + i);
                              g.drawLine(mLastPoint.x, mLastPoint.y - i, p.x, p.y - i);
//                              System.out.println("y");
//                              System.out.println("angle = " + angle / Math.PI * 180);
                    else {
                         for (int i = 0; i < mBrushSize / 2; i ++) {
                              g.drawLine(mLastPoint.x + i, mLastPoint.y, p.x + i, p.y);
                              g.drawLine(mLastPoint.x  - i, mLastPoint.y, p.x - i, p.y);
//                              System.out.println("x");
//                    System.out.println("new = " + PaintUtils.printPoint(p));
//                    System.out.println("last = " + PaintUtils.printPoint(mLastPoint));
                    //System.out.println("distance = " + distance);
                    //Graphics2D g2 = (Graphics2D) g;
                    //g2.translate(mLastPoint.x + mBrushSize / 2, mLastPoint.y);
                    //g2.rotate(angle);
                    //g2.fillRect(0, 0, (int) Math.ceil(distance), mBrushSize);
                    //g2.rotate(-angle);
                    //g2.translate(-mLastPoint.x + mBrushSize / 2, -mLastPoint.y);
//                    g.setColor(Color.RED);
//                    g.drawRect(p.x, p.y, 1, 1);
               mLastPoint = p;
               g.dispose();
               repaint();
          public void mouseMoved(MouseEvent me) {}
          public void mouseReleased(MouseEvent me) {
               mLastPoint = null;
     private void handleResize() {
          Dimension size = getSize();
          mSizeChanged = false;
          if (mImg == null) {
               mImg = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB);
               Graphics g = mImg.getGraphics();
               g.setColor(getBackground());
               g.fillRect(0, 0, mImg.getWidth(), mImg.getHeight());
               g.dispose();
          else {
               int newWidth = Math.max(mImg.getWidth(),getWidth());
               int newHeight = Math.max(mImg.getHeight(),getHeight());
               if (newHeight == mImg.getHeight() && newWidth == mImg.getWidth()) {
                    return;
               BufferedImage bi2 = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
               Graphics g = bi2.getGraphics();
               g.setColor(getBackground());
               g.fillRect(0, 0, bi2.getWidth(), bi2.getHeight());
               g.drawImage(mImg, mImg.getWidth(), mImg.getHeight(), null);
               g.dispose();
               mImg = bi2;
     public JToolBar getToolBar() {
          if (mToolBar == null) {
               mToolBar = new ToolBar();
          return mToolBar;
     private ToolBar mToolBar;
     public static void main (String args[]) {
          PaintArea pa = new PaintArea();
          JPanel parent = new JPanel();
          parent.setLayout(new BorderLayout());
          parent.add(pa, BorderLayout.CENTER);
          pa.setPreferredSize(new Dimension(150, 150));
          parent.add(pa.getToolBar(), BorderLayout.NORTH);
          WindowUtilities.visualize(parent);
     protected class CListener extends ComponentAdapter {
          public void componentResized(ComponentEvent ce) {
               mSizeChanged = true;
MathUtils.java
===========
* Created on Nov 7, 2004 by @author Tom Jacobs
package tjacobs;
import java.awt.Point;
* Simple math routines spelled out. There's euclideanDistance, factorial,
* combinations, distance.<p>
* Pretty standard really.
public class MathUtils {
     private MathUtils() {
          super();
     public static double euclideanDistance(Point p1, Point p2) {
          return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
     public static int factorial(int x) {
          int pow = 1;
          while (x > 1) {
               pow = pow * x;
               x--;
          return pow;
     public static int getCombinations(int total, int picks, boolean replacing, boolean ordered) {
          int ans = 0;
          if (replacing && ordered) {
               ans = (int)Math.pow(total, picks);
               //total / Math.pow(totalpicks)
          else if (!replacing && ordered){
               ans = factorial (total);
               ans /= factorial(total - picks);
          } else if (replacing && !ordered) {
               ans = factorial(total + picks - 1);
               ans /= factorial(picks);
               ans /= factorial(total - picks);
          else if (!replacing && !ordered) {
               ans = factorial(total);
               ans/= factorial(picks);
               ans/= factorial(total - picks);               
          return ans;
     public static double distance (Point p1, Point p2) {
          return distance(p1.x, p1.y, p2.x, p2.y);
     public static double distance(double x1, double y1) {
          return distance(x1, y1, 0, 0);
     public static double distance (double x1, double y1, double x2, double y2) {
          return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
     public static double angle (Point p1, Point p2) {
          return angle(p1.x, p1.y, p2.x, p2.y);
     public static double angle (double x1, double y1, double x2, double y2) {
          double xdiff = x1 - x2;
          double ydiff = y1 - y2;
          double tan = xdiff / ydiff;
          double atan = Math.atan2(ydiff, xdiff);
          return atan;
     public static double reflectOff(double ray, double reflectOff) {
          return reflectOff + reflectOff - ray;
     //Testing only
/*     public static void main(String args[]) {
          System.out.println(reflectOff(0, Math.PI / 4) / Math.PI);
          System.out.println(reflectOff(Math.PI / 2, Math.PI) / Math.PI);
          System.out.println(reflectOff(5 * Math.PI / 4, Math.PI / 2) / Math.PI);
          System.out.println(reflectOff(Math.PI, Math.PI / 2));
WindowUtils.java
===============
package tjacobs.ui;
import java.awt.*;
import java.awt.event.*;
import javax.swing.ImageIcon;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.Popup;
import javax.swing.SwingUtilities;
public abstract class WindowUtilities {
     public static final int RESIZE_MARGIN_SIZE = 4;
     private static Window sExitWindow = null;
     public static interface CreatePopupWindow {
          public JDialog createPopupWindow(Point p);
     * Returns an point which has been adjusted to take into account of the
     * desktop bounds, taskbar and multi-monitor configuration.
     * <p>
     * This adustment may be cancelled by invoking the application with
     * -Djavax.swing.adjustPopupLocationToFit=false
    public static Point adjustPopupLocationToFitScreen(Component popup, Component invoker, int xposition, int yposition) {
     Point p = new Point(xposition, yposition);
        if(//popupPostionFixDisabled == true ||
                    GraphicsEnvironment.isHeadless())
            return p;
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Rectangle screenBounds;
        Insets screenInsets;
        GraphicsConfiguration gc = null;
        // Try to find GraphicsConfiguration, that includes mouse
        // pointer position
        GraphicsEnvironment ge =
            GraphicsEnvironment.getLocalGraphicsEnvironment();
        GraphicsDevice[] gd = ge.getScreenDevices();
        for(int i = 0; i < gd.length; i++) {
            if(gd.getType() == GraphicsDevice.TYPE_RASTER_SCREEN) {
GraphicsConfiguration dgc =
gd[i].getDefaultConfiguration();
if(dgc.getBounds().contains(p)) {
gc = dgc;
break;
// If not found and we have invoker, ask invoker about his gc
if(gc == null && invoker != null) {
gc = invoker.getGraphicsConfiguration();
if(gc != null) {
// If we have GraphicsConfiguration use it to get
// screen bounds and insets
screenInsets = toolkit.getScreenInsets(gc);
screenBounds = gc.getBounds();
} else {
// If we don't have GraphicsConfiguration use primary screen
// and empty insets
screenInsets = new Insets(0, 0, 0, 0);
screenBounds = new Rectangle(toolkit.getScreenSize());
int scrWidth = screenBounds.width -
Math.abs(screenInsets.left+screenInsets.right);
int scrHeight = screenBounds.height -
Math.abs(screenInsets.top+screenInsets.bottom);
Dimension size;
size = popup.getPreferredSize();
if( (p.x + size.width) > screenBounds.x + scrWidth )
p.x = screenBounds.x + scrWidth - size.width;
if( (p.y + size.height) > screenBounds.y + scrHeight)
p.y = screenBounds.y + scrHeight - size.height;
/* Change is made to the desired (X,Y) values, when the
PopupMenu is too tall OR too wide for the screen
if( p.x < screenBounds.x )
p.x = screenBounds.x ;
if( p.y < screenBounds.y )
p.y = screenBounds.y;
return p;
     public static MouseListener addAsPopup(final CreatePopupWindow cpw, Component owner) {
          if (cpw == null || owner == null) {
               return null;
          MouseListener ml = new MouseAdapter() {
               CreatePopupWindow create = cpw;
               public void mousePressed(MouseEvent ev) {
                    testPopup(ev);
               public void mouseReleased(MouseEvent ev) {
                    testPopup(ev);
               private void testPopup(MouseEvent ev) {
                    if (ev.isPopupTrigger()) {
                         final JDialog pop = create.createPopupWindow(ev.getPoint());
                         //pop.setUndecorated(true);
                         if (pop == null) {
                              return;
                         Window w = SwingUtilities.getWindowAncestor(ev.getComponent());
                         pop.setLocation(ev.getX() + w.getX(), ev.getY() + w.getY());
                         pop.pack();
                         pop.addWindowListener(new WindowAdapter() {
                              public void windowDeactivated(WindowEvent we) {
                                   pop.dispose();
                         pop.setFocusableWindowState(true);
                         pop.setVisible(true);
                         pop.requestFocus();
                         //pop.show();
          owner.addMouseListener(ml);
          return ml;
     public static MouseListener addAsPopup(final JPopupMenu popup, Component owner) {
          if (popup == null || owner == null) {
               return null;
          //popup.setUndecorated(true);
          MouseListener ml = new MouseAdapter() {
               JPopupMenu pop = popup;
               public void mousePressed(MouseEvent ev) {
                    testPopup(ev);
               public void mouseReleased(MouseEvent ev) {
                    testPopup(ev);
               private void testPopup(MouseEvent ev) {
                    if (ev.isPopupTrigger()) {
                         //pop.setLocation(ev.getPoint());
                         //pop.pack();
                         //pop.setVisible(true);
                         //JPopupMenu pop = new JPopupMenu();
                         //pop.add(new JMenuItem("Hi"));
                         pop.show(ev.getComponent(), ev.getX(), ev.getY());
          owner.addMouseListener(ml);
          return ml;
     public static MouseListener addAsPopup(final JDialog popup, Component owner) {
          if (popup == null || owner == null) {
               return null;
          //popup.setUndecorated(true);
          MouseListener ml = new MouseAdapter() {
               Window pop = popup;
               public void mousePressed(MouseEvent ev) {
                    testPopup(ev);
               public void mouseReleased(MouseEvent ev) {
                    testPopup(ev);
               private void testPopup(MouseEvent ev) {
                    if (ev.isPopupTrigger()) {
                         pop.setLocation(ev.getPoint());
                         pop.pack();
                         pop.setVisible(true);
          owner.addMouseListener(ml);
          return ml;
     public static Point getBottomRightOfScreen(Component c) {
     Dimension scr_size = Toolkit.getDefaultToolkit().getScreenSize();
     Dimension c_size = c.getSize();
     return new Point(scr_size.width - c_size.width, scr_size.height - c_size.height);
     public static Window visualize(Component c) {
          return visualize(c, sExitWindow == null);
     public static Window visualize(Image im) {
          return visualize(new JLabel(new ImageIcon(im)));
     public static Window visualize (Component c, int width, int height) {
          return visualize(c, sExitWindow == null, width, height);
     public static Window visualize(Component c, boolean exit, int width, int height) {
          JFrame f;
          Window w;
          if (c instanceof Window) {
               w = (Window) c;
          else {
               f = new JFrame();
               f.getContentPane().add(c);
               w = f;
          // to be thread safe, this should be synchonized.
          // but it doesn't really matter in everyday situations
          if (sExitWindow == null) {
               sExitWindow = w;
          w.setSize(width, height);
          w.setLocation(100, 100);
          if (exit) {
               w.addWindowListener(new WindowClosingActions.Exit());
          w.setVisible(true);
          return w;          
     public void center(Window w) {
          Dimension dim = w.getSize();
          Dimension scr = Toolkit.getDefaultToolkit().getScreenSize();
          w.setLocation((scr.width - dim.width)/2, (scr.height - dim.height)/2);
     public static Window visualize(Component c, boolean exit) {
          JFrame f;
          Window w;
          if (c instanceof Window) {
               w = (Window) c;
          else {
               f = new JFrame();
               f.getContentPane().add(c);
               w = f;
          w.pack();
          w.setLocation(100, 100);
          if (exit) {
               w.addWindowListener(new WindowClosingActions.Exit());
          w.setVisible(true);
          return w;