Weird displaying issues between computers?

Hey guys, I'm having trouble with this program I'm making. When I run it at school, everything works fine. However, when I run it at home, the program glitches up kinda like when your computer freezes up and you start seeing double windows when you try to move it? It's really hard to explain, so I took pictures to try my best to explain what is going on.

When I first start up the program it looks like this:

Now, when I click somewhere to draw a shape (part of what the program is supposed to do), it glitches up like this:

This isn't even a part of the program, I can paint over this:

Also, when I try to move the window itself, for example, let's say I move below the desktop so I can only see half of it, it will erase some of it:

Like I said, this is a really hard problem to explain, and considering that it works at school, I don't think it has to deal anything with the code itself. Both Java versions on computers are updated.

Did you overridde paintComponent and forget to call super.paintComponent as the first line?

Thanks man, that helped. One thing though, now that I call super.paintComponent(g), I can only draw one thing at a time? Is there any simple fixes too this?

Keep a List of things that need to be painted, then paint everything in that List.

Thanks, I was thinking that, I was just curious if there was any more efficient ways of doing so.

You can create a new BufferedImage, use getGraphics to get its Graphics object, and do all your drawing to that.

Then use g.drawImage(img, 0, 0, this) in the paintComponent method to copy the contents to the panel's Graphics object. Be careful to check in the paintComponent method that the two images are still the same size, i.e. deal with the case where the window has been resized.

Here's an example of double-buffering that I copied from a website that might help:

(when I tried a similar example I had problems getting createImage() to work - it won't work if your panel isn't visible, so instead I just used something along the lines of Image bi = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB) instead.)

/* Drawing in applets is almost always done with double-buffering.
This means that drawing is first done to an offscreen image, and when all
is done, the offscreen image is drawn on the screen.
This reduces the nasty flickering applets otherwise have.

Above you see:
No Double-buffering : It flickers because everything is draw straight to the screen.
Bad double-buffering: Same as this below but without the update() method
Double Buffering: Example of this source.
*/

import java.applet.*;
import java.awt.event.*;
import java.awt.*;

public class DoubleBuffering extends Applet implements MouseMotionListener
{
     // The object we will use to write with instead of the standard screen graphics
     Graphics bufferGraphics;
     // The image that will contain everything that has been drawn on
     // bufferGraphics.
     Image offscreen;
     // To get the width and height of the applet.
     Dimension dim;
     int curX, curY;

public void init() 
     {
          // We'll ask the width and height by this
          dim = getSize();
          // We'll redraw the applet eacht time the mouse has moved.
          addMouseMotionListener(this);
          setBackground(Color.black);
          // Create an offscreen image to draw on
          // Make it the size of the applet, this is just perfect larger
          // size could slow it down unnecessary.
          offscreen = createImage(dim.width,dim.height);
          // by doing this everything that is drawn by bufferGraphics
          // will be written on the offscreen image.
          bufferGraphics = offscreen.getGraphics();
     }

public void paint(Graphics g) 
     {
          // Wipe off everything that has been drawn before
          // Otherwise previous drawings would also be displayed.
          bufferGraphics.clearRect(0,0,dim.width,dim.width);
          bufferGraphics.setColor(Color.red);
          bufferGraphics.drawString("Double-buffered",10,10);
          // draw the rect at the current mouse position
          // to the offscreen image
          bufferGraphics.fillRect(curX,curY,20,20);
          // draw the offscreen image to the screen like a normal image.
          // Since offscreen is the screen width we start at 0,0.
          g.drawImage(offscreen,0,0,this);
     }

// Always required for good double-buffering.
     // This will cause the applet not to first wipe off
     // previous drawings but to immediately repaint.
     // the wiping off also causes flickering.
     // Update is called automatically when repaint() is called.

public void update(Graphics g)
     {
          paint(g);
     }

// Save the current mouse position to paint a rectangle there.
     // and request a repaint()
     public void mouseMoved(MouseEvent evt) 
     {
          curX = evt.getX();
          curY = evt.getY();
          repaint();
     }

// The necessary methods.
     public void mouseDragged(MouseEvent evt) 
     {
     }

}

I was just curious if there was any more efficient ways of doing so.

It depends on your exact requirement.

Custom Painting Approaches gives working examples of both approaches suggested here as well as some pros/cons of each approach.