paint, paintComponent vs repaint?

[Richard Warner]

I am really struggling with getting an applet program to repaint outside of minimizing and then bringing to the foreground again my applet window (which it does repaint, and quite neatly, revealing the underlying mechanics at work as intended).

But resizing after each input is getting really, really old in testing my program. The compiler gets angry whenever I try to call any of the methods to repaint from events in my primary object (A Selection Class object named selector) trying to make me turn even more of my program bits and bobs static (actions I had taken to satiate demands from other classes) or - more disconcerting - screaming that I need to input a Graphics object parameter, but when I do so, all kinds of everything becomes broken. It gets even angrier and crazier on the rabbit-trails elsewhere. Goal: I would like the program to repaint every so often on its own.

*afterthought* maybe I could prebuild each Graphics object in another class extending Graphics class then treat them as blocks of image? Is that even possible? Trying to hold out on doing a load of custom artwork for the time being.

I read that there is no way to directly call the paint() method, yet, that is what repaint() seems to do, from everything else I read and see. But repaint() and I are NOT friends. Yet.

But for me it doesn't seem to work any which way I approach this thing. I don't want to post too much code initially, but I really don't know where to start. Tell me if you need more info. I'm thinking lines 51 of Flank Class should (indirectly) invoke the method at line 61 (the following Blocks of code Classes Deck and Card are there just to show you what lines 62/63 call.). But it acts like it doesn't. It probably doesn't and I have no clue why others can use it in threads to get what they want and I can't. Repaint() doesn't take parameters. Maybe there's a command in there to resize my window to some arbitrary size and back again like I've been doing manually? I'm desperate to get this working.

package flankgame;

import java.applet.Applet;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class Flank extends Applet implements Runnable, KeyListener {


	public static final int WIDTH = 100;
	public static final int HEIGHT = 60;
	public static final int SCALE = 8;
	public static final String NAME = "Flank WORKSPACE! TODO RENAME";
	public static final Color BACKGROUND = Color.LIGHT_GRAY;

// objects necessary for game
	private static Deck allyDeck;
	private static Deck axisDeck;
	private static Rulebook rules;
	private static Selection selector;
	
	@Override
	public void init() {
		super.init();
		rules = new Rulebook();
		allyDeck = new Deck(true);
		axisDeck = new Deck(false);
		selector = new Selection();
		setSize(WIDTH * SCALE, HEIGHT * SCALE);
		setBackground(BACKGROUND);
		setFocusable(true);
		addKeyListener(this);
		Frame frame = (Frame) this.getParent().getParent();
		frame.setTitle(NAME);

	}

	@Override
	public void start() {
		selector.update();
		Thread thread = new Thread();
		thread.start();
	}

	@Override
	public void run() {

		while(true){
			selector.update();
			repaint();
			try {
				Thread.sleep(78);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
	
	public void paint(Graphics g) {
		axisDeck.paintComponent(g);
		allyDeck.paintComponent(g);
	}
// other irrelevant junk

public class Deck {

 // ... irrelevant constructor and other junk here, then...

	public void paintComponent(Graphics g){
		// axis deck
		if (allyFaction == false) {
			// clean up board
			for (int r = 0; r < ROWS; r++) {
				for (int c = deck[r].getPile().size() - 1; c >= 0; c--) {
					int mod_i = (r * 132) + LEFT_MARGIN;
					int mod_j = (c * 16) + AXIS_TOP_MARGIN;
					g.setColor(Flank.BACKGROUND);
					g.drawRect(mod_i, 0- mod_j, Card.WIDTH, Card.HEIGHT);
				}
			}
			// paint new
			for (int r = 0; r < ROWS; r++) {
				for (int c = deck[r].getPile().size() - 1; c >= 0; c--) {
					Card card = deck[r].getPile().get(c);
					int mod_i = (r * 132) + LEFT_MARGIN;
					int mod_j = (c * 16) + AXIS_TOP_MARGIN;
					card.draw(g, mod_i, 0 - mod_j);
				}
			}
		}
		// ally deck
		if (allyFaction == true) {
			// clean up board
			for (int r = 0; r < ROWS; r++) {
				for (int c = deck[r].getPile().size() - 1; c >= 0; c--) {
					int mod_i = (r * 132) + LEFT_MARGIN;
					int mod_j = (c * 16) + ALLIED_TOP_MARGIN;
					g.setColor(Flank.BACKGROUND);
					g.drawRect(mod_i, mod_j, Card.WIDTH, Card.HEIGHT);
				}
			}
			// paint new
			for (int r = 0; r < ROWS; r++) {
				for (int c = deck[r].getPile().size() - 1; c >= 0; c--) {
					Card card = deck[r].getPile().get(c);
					int mod_i = (r * 132) + LEFT_MARGIN;
					int mod_j = (c * 16) + ALLIED_TOP_MARGIN;
					card.draw(g, mod_i, mod_j);
				}
			}
		}
	}

public abstract class Card {

// all kinds of irrelevant junk then...

	public void draw(Graphics g, int x, int y) {
		drawCardFrame(g, x, y);
		drawBranchDecal(g, x, y);
		drawCardDetails(g, x, y);
	}

	private void drawCardFrame(Graphics g, int x, int y) {
		g.setColor(CARD_FACE);
		g.fillRoundRect(x, y, WIDTH, HEIGHT, ARC, ARC);
		g.setColor(CARD_EDGE);
		g.drawRoundRect(x, y, WIDTH, HEIGHT, ARC, ARC);
	}

	private void drawBranchDecal(Graphics g, int x, int y) {
		g.setColor(getColors());
		g.fillRect(x + 3, y + 2, DIV_DECAL_WIDTH, DIV_DECAL_HEIGHT);
		// ... yada yada 6 more lines like that of junk...
	}
	
	private void drawCardDetails(Graphics g, int x, int y) {
		g.drawString(getName(), x + 34, y + DIV_DECAL_HEIGHT - 1);
		g.drawString(getName(), x + DIV_DECAL_WIDTH - 10, y + HEIGHT - 4);
		g.drawString("" + getRank(), x + WIDTH - 10, y + DIV_DECAL_HEIGHT - 1);
		g.drawString("" + getRank(), x + 3, y + HEIGHT - 4);
	}

I've tried rewriting the whole damn thing as a JPanel, as a JFrame (before I learned those two objects are just brothers with different layout managers) and then as a Canvas (also before I did any research on what it was). In the end, Applet is as good as any for what I need, so it seems from what I read, anyway.

I've mimicked and modified, mixing and matching successful techniques from what I've seen others do and all of my versions fail in the same brutal way. Maybe I just don't understand Graphics objects, though from everything I read they seem straightforward. It is possible I don't fully understand threading, but that seems straightforward to me as well (thread just branches the program much like using conditionals, but flitting back and forth between each branch's execution priority, right?). I have yet to implement the other thread pathway, which I'm guessing I'll need separated out to manage some animations, etc.

Thank you to those willing to take the time to look at this! The input I've received here is always really, really helpful.

[Paul Clapham]

If you want to do something on a regular schedule in your GUI, then the tool for that is a Swing Timer object. Here's a link to the tutorial: How to Use Swing Timers.

But I see you aren't using Swing. Why on earth not? You should switch to using JApplet.

[Piet Souris]

hi Richard,

although you start a Thread in your 'start' method, the problem is that that thread isn't
doing anything at all.

So you might try this:

@Override
    public void start() { 
        selector.update(); 
        Thread thread = new Thread(this); 
        thread.start(); 
    } 

In that case, I would also advise to put in a method 'stop'
(see the Applet API), in which you kill this thread.

However, this also has some consequences, so in the end it is best
to follow Pauls advise: use a JPanel instead of an applet, and use
a Swing Timer. That will make things far more easy. Should that give
any problems: let us know!

Greetz,
Piet

[Campbell Ritchie]

Good advice from PS. Avoid starting new threads for GUIs because they are not thread‑safe. If you need to run something in parallel find out about the SwingWorker class. Applets are obsolete because of security problems, and I shall move this discussion to the GUIs forum.

[Rob Camick]

I've tried rewriting the whole damn thing as a JPanel, as a JFrame

That is the way it should be done. You create a JPanel and do the custom painting on this panel, then you add the panel to the frame. Custom painting is done by overriding the paintComponet(...) method.

And don't forget to invoke super.paintComponent() at the start of the overridden method.

Your current code is a bit of a mess. First you extend Applet and then you create a Frame. This is wrong and 15 years out of date. As has already been mentioned people don't used Applets, or AWT components. Just use Swing components.

I suggest you start by reading the Swing tutorial on Custom Painting for the basics and simple examples to start with. Learn painting basics first before writing more complex code.

[Richard Warner]

Ah, thank you all so much!

I will rewrite this as you say, as a JFrame with a JPanel within it. I had gone one or the other but not both. I had not heard about Swing's timers, I'll learn how that works to implement this.

And the word "this" did indeed fix all my dead thread code. With just that keyword, it all started refreshing as I had hoped, but since I'm headed down a dead-end, outdated path, I'll start fresh!

Folks, this is huge for me! (Since my version 1.7, when I first encountered this about two weeks ago, I've made basically a new version of the game every night by 0.1 increments, up to 2.9) This was a huge leap forward to know that I should revamp this and approach a whole new way!