Hola, tengo el siguiente codigo , lo que hace en mi programa es mostrar unas celdas de colores, lo que desearia en vez de los colores se mostara una imagen.

si no me equico tendria que declarar una imagen, pasarle la foto con el toolkit y con el drawimagen mostrarla, pero no obtngo resultado. aqui dejo el codigo haber si alguien puede ayudar.


package juego;

import java.awt.*;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.util.Enumeration;
import java.util.Vector;

/**
* matriz de celdas
*/
public class pizarra extends Canvas
{
private boolean celdaBajoRaton;
private Image ImagenFueradePantalla;
private Graphics GraficoFueradePantalla;
private Image ImagenDibujadaFueradePantalla;
/* Imagen que contiene la matriz dibujada.*/
private Graphics GraficoDibujadoFueradePantalla;
private int tamañoCelda;
private MatrizDeCeldas matriz;
private Vector listeners;
private int nuevoTamañoCelda;
private Formas nuevaforma;

/**
* Crea una nueva instancia de pizarra */
public pizarra(MatrizDeCeldas matriz, int tamañoCelda) {
this.matriz = matriz;
this.tamañoCelda = tamañoCelda;

setBackground(new Color(0x999999));

addMouseListener(new MouseAdapter() {
public void mouseReleased(MouseEvent e) {
dibujar(e.getX(), e.getY());
}
public void mousePressed(MouseEvent e) {
guardarCeldaBajoRaton(e.getX(), e.getY());
}
});

addMouseMotionListener(new MouseMotionAdapter() {
public void mouseDragged(MouseEvent e) {
dibujar(e.getX(), e.getY());
}
});
addComponentListener(new ComponentListener() {
public void componentResized(ComponentEvent e) {
resized();
repaint();
}
public void componentMoved(ComponentEvent e) {}
public void componentHidden(ComponentEvent e) {}
public void componentShown(ComponentEvent e) {}
});

}

/**
* Establece el tamaño de la celda */
public void setTamañoCelda( int tamañoCelda ) {
this.tamañoCelda = tamañoCelda;
resized();
repaint();
}

/*La matriz cambia de tamaño. */
public void resized() {
if ( nuevoTamañoCelda != 0 ) {
tamañoCelda = nuevoTamañoCelda;
nuevoTamañoCelda = 0;
}
Dimension canvasDim = this.getSize();
ImagenFueradePantalla = null;
ImagenDibujadaFueradePantalla = null;
matriz.resize(canvasDim.width/tamañoCelda, canvasDim.height/tamañoCelda);
if ( nuevaforma != null ) {
try {
setFormas( nuevaforma );
} catch (FormasException e) { }
}
}

/* estado de la celda para ser dibujada. */
public void guardarCeldaBajoRaton(int x, int y) {
try {
celdaBajoRaton = matriz.getCelda(x / tamañoCelda, y / tamañoCelda);
} catch (java.lang.ArrayIndexOutOfBoundsException e) { }
}

/* Dibujar en esta celda. */
public void dibujar(int x, int y) {
try {
matriz.setCelda(x / tamañoCelda, y / tamañoCelda, !celdaBajoRaton );
repaint();
} catch (java.lang.ArrayIndexOutOfBoundsException e) { }
}

/*Actualiza la imagen usando un doble buffer. */
public void update(Graphics g) {
Dimension d = getSize();
if ((ImagenFueradePantalla == null)) {
ImagenFueradePantalla = createImage(d.width, d.height);
GraficoFueradePantalla = ImagenFueradePantalla.getGraphics();
}
paint(GraficoFueradePantalla);
g.drawImage(ImagenFueradePantalla, 0, 0, null);
}

/* Dibuja esta generación.*/
public void paint(Graphics g) {
if (ImagenDibujadaFueradePantalla == null) {
Dimension dim = matriz.getDimension();
Dimension d = getSize();
ImagenDibujadaFueradePantalla = createImage(d.width, d.height);
GraficoDibujadoFueradePantalla = ImagenDibujadaFueradePantalla.getGraphics();
GraficoDibujadoFueradePantalla.setColor(getBackground());
GraficoDibujadoFueradePantalla.fillRect(0, 0, d.width, d.height);
GraficoDibujadoFueradePantalla.setColor(Color.gray);
GraficoDibujadoFueradePantalla.fillRect(0, 0, tamañoCelda * dim.width - 1, tamañoCelda * dim.height - 1);
GraficoDibujadoFueradePantalla.setColor(getBackground());
for (int x = 1; x < dim.width; x++) {
GraficoDibujadoFueradePantalla.drawLine(x * tamañoCelda - 1, 0, x * tamañoCelda - 1, tamañoCelda * dim.height - 1);
}
for (int y = 1; y < dim.height; y++) {
GraficoDibujadoFueradePantalla.drawLine( 0, y * tamañoCelda - 1, tamañoCelda * dim.width - 1, y * tamañoCelda - 1);
}
}
g.drawImage(ImagenDibujadaFueradePantalla, 0, 0, null);
// dibujar las celdas vivas
g.setColor(Color.red);
Enumeration enumerer = matriz.getenumer();
Celda c;
while ( enumerer.hasMoreElements() ) {
c = (Celda)enumerer.nextElement();
g.fillRect(c.col * tamañoCelda, c.fila * tamañoCelda, tamañoCelda - 1, tamañoCelda - 1);
}
}

/*tamaño .*/
public Dimension getPreferredSize() {
Dimension dim = matriz.getDimension();
return new Dimension( tamañoCelda * dim.width, tamañoCelda * dim.height );
}

/**
* tamaño minimo celda */
public Dimension getMinimumSize() {
return new Dimension( tamañoCelda, tamañoCelda );
}

/**
* Cambios a aplicar después de un redimensionamiento de la ventana.
* @param nuevaforma nueva Forma
* @param nuevoTamañoCelda nuevo tamaño de Celda
*/
public void aplicarDespuesDeRedimensionDeVentana( Formas nuevaforma, int nuevoTamañoCelda ) {
this.nuevaforma = nuevaforma;
this.nuevoTamañoCelda = nuevoTamañoCelda;
}

/**
* Dibuja formas en la matríz. */
public synchronized void setFormas(Formas forma) throws FormasException {
int xOffset;
int yOffset;
// int[][] matrizDeForma;
Dimension dimFormas;
Dimension dimMatriz;
int i;

// Obtener propiedades de la forma
//shapeGrid = shape.getFormas();
dimFormas = forma.getDimension();
dimMatriz = matriz.getDimension();

if (dimFormas.width > dimMatriz.width || dimFormas.height > dimMatriz.height)
throw new FormasException( "La figura no entra en el lienzo (matriz: "+dimMatriz.width+" x, "+dimMatriz.height+" y, Forma: "+dimFormas.width+" x, "+dimFormas.height+"y)");

// centro de la figura
xOffset = (dimMatriz.width - dimFormas.width) / 2;
yOffset = (dimMatriz.height - dimFormas.height) / 2;
matriz.clear();

// dibujar forma
Enumeration celdas = forma.getCeldas();
while (celdas.hasMoreElements()) {
int[] celda = (int[]) celdas.nextElement();
matriz.setCelda(xOffset + celda[0], yOffset + celda[1], true);
}

}
}

Responder