# Applet läuft in Eclipse aber im Browser nicht



## Gast (22. Mai 2006)

Hallo,

habe mein Applet fertig programmiert und möchte es nun im Browser starten.

Haben alle src Dateien kompiliert, alle images sind vorhanden und alles anschließend signiert.

Mein Browser(egal welcher) lädt das Applet, fragt nach der Signatur, und nach Annahme ist das Applet geladen, jedoch 

ohne meine images. Einfach nur ein Grauer Bildschirm. 

Beim Testen in Eclipse läuft es einwandfrei !!!

Was ist denn jetzt bitte los???
  :bahnhof:


----------



## Wildcard (22. Mai 2006)

Hast du die Bilder auch in das jar gepackt und sind sie entsprechen referenziert?


----------



## Gast (22. Mai 2006)

sind alle im jarFile...was meinst du unter richtig referenziert ??


----------



## Wildcard (22. Mai 2006)

Poste bitte mal eine Codezeile wie du auf die Bilder zugreifst.


----------



## Gast (22. Mai 2006)

```
AbstractAction pixel = new AbstractAction("Pixel", new ImageIcon("images/pixel.png")) {
```


nee das ist schon alles korrekt....Ich dreh gleich durch, das musst doch gehen... Habe nichts verändert, wenns in Eclipse läuft muss es doch im Browser auch laufen


----------



## Wildcard (22. Mai 2006)

Wenn die Bilder in einem jar file liegen müssen sie anders referenziert werden.

```
getClass().getResource(name);
```


----------



## Gast (22. Mai 2006)

Ach sooooooo...

aber das läuft dann auch in Eclipse oder ?? Also ich werds jetzt mal gleich in Eclipse ändern und dann nochmal alles kompilieren und signieren.

Mensch Danke dir :!:


----------



## Gast (22. Mai 2006)

Habs geändert, läuft in Eclipse...Im browser immernoch beim alten...Keine images!!!

Meine selbst wenn ich im Code eins übersehen habe müsste er doch die wo ichs geänderthab doch schonmal anzeigen
oder ?? 

Ich versteh die Welt nicht mehr


----------



## Wildcard (22. Mai 2006)

```
new ImageIcon(getClass().getResource("/images/pixel.png"))
```
in etwa so sollte das bei dir aussehen.
Nicht vergessen den Classloader-Cache zu löschen wenn du das jar file änderst


----------



## Gast (22. Mai 2006)

```
new ImageIcon(getClass().getResource("/images/pixel.png"))
```

hab es so im Code und es will nicht !!! hattes es vorher auch mal ohne das erste / vor images.

Classloader Cache?? ich erzeuge mit immer ein ganz neues jar File...

Nur was mach in nu :?:


----------



## Wildcard (22. Mai 2006)

Du musst die Java konsole öffnen (unter Windows erscheint eine Kaffetasse im tray sobald das Applet startet) und dann x drücken um den Classloader cache zu löschen. Ansonsten wird die gecachte(alte) version deines jars verwendet.


----------



## Gast (22. Mai 2006)

Habe die schnauze voll...

kann mal eine drübergucken der GERADE LUST HAT 


 :roll:  


Klasse 1

```
public class MalerApplet extends JApplet {

	/*
	 * Erzeugt ein Fenster und stellt darin das Zeichenbrett und eine
	 * Werkzeugleiste dar.
	 *
	 */

	String host = "localhost";
    int port = 5000;
    String url = "http://www.google.de/"; //TestAdresse auf die weitergeleitet werden soll nach Bildübertragung

    
	public void init() {
		try {

			final Zeichenbrett zeichenbrett = new Zeichenbrett();
			getContentPane().add(new JScrollPane(zeichenbrett),
			BorderLayout.CENTER);
			initToolBar(zeichenbrett);



		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/*
	 * Hier werden ein paar Funktionen in einem Toolbar angeordnet mit denen die
	 * Zeichenflächen-Funktionalität geändert/genutzt werden kann.
	 */
	private void initToolBar(final Zeichenbrett zeichenbrett) {
		JToolBar tb = new JToolBar(JToolBar.VERTICAL);
		tb.setFloatable(false);

		AbstractAction info = new AbstractAction("Info", new ImageIcon(getClass().getResource("/images/quest.gif"))) {
			public void actionPerformed(ActionEvent e) {
				zeichenbrett.setVerwendetesWerkzeug(Zeichenbrett.TOOL_PIXEL);
			}
		}; info.putValue(Action.SHORT_DESCRIPTION, "Infos zum Applet");
		tb.add(info);

		AbstractAction pixel = new AbstractAction("Pixel", new ImageIcon(getClass().getResource("/images/pixel.png"))) {
			public void actionPerformed(ActionEvent e) {
				zeichenbrett.setVerwendetesWerkzeug(Zeichenbrett.TOOL_PIXEL);
			}
		}; pixel.putValue(Action.SHORT_DESCRIPTION, "feiner Pinsel");
		tb.add(pixel);

		AbstractAction rect = new AbstractAction("Rechteck", new ImageIcon(getClass().getResource("/images/rect.png"))) {
			public void actionPerformed(ActionEvent e) {
				zeichenbrett.setVerwendetesWerkzeug(Zeichenbrett.TOOL_RECTANGLE);
			}
		};
		rect.putValue(Action.SHORT_DESCRIPTION, "eckiger Pinsel");
		tb.add(rect);

		AbstractAction oval = new AbstractAction("Kreis", new ImageIcon(getClass().getResource("/images/oval.png"))) {
			public void actionPerformed(ActionEvent e) {
				zeichenbrett.setVerwendetesWerkzeug(Zeichenbrett.TOOL_CIRCLE);
			}
		};
		oval.putValue(Action.SHORT_DESCRIPTION, "runder Pinsel");
		tb.add(oval);

		AbstractAction fillrect = new AbstractAction("FillRect", new ImageIcon(getClass().getResource("/images/rechteck.png"))) {
			public void actionPerformed(ActionEvent e) {
				zeichenbrett.setVerwendetesWerkzeug(Zeichenbrett.TOOL_FILLRECT);
			}
		};
		fillrect.putValue(Action.SHORT_DESCRIPTION, "Rechteck malen");
		tb.add(fillrect);

		AbstractAction filloval = new AbstractAction("FillOval", new ImageIcon(getClass().getResource("/images/kreis.png"))) {
			public void actionPerformed(ActionEvent e) {
				zeichenbrett.setVerwendetesWerkzeug(Zeichenbrett.TOOL_FILLOVAL);
			}
		};
		filloval.putValue(Action.SHORT_DESCRIPTION, "Kreis malen");
		tb.add(filloval);


		AbstractAction stamp = new AbstractAction("Bild", new ImageIcon(getClass().getResource("/images/stempel.gif"))) {
			public void actionPerformed(ActionEvent e) {

				try {
					Image img = ImageIO.read(new File("images/a9.gif"));
					zeichenbrett.setStempelBild(img);
					zeichenbrett.setVerwendetesWerkzeug(Zeichenbrett.TOOL_STAMP);
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}

			}
		};
		stamp.putValue(Action.SHORT_DESCRIPTION, "Stempelfunktion");
		tb.add(stamp);

		AbstractAction stampchoose = new AbstractAction("FileChoose", new ImageIcon(getClass().getResource("/images/ico.gif"))) {
			public void actionPerformed(ActionEvent e) {
				JFileChooser chooser = new JFileChooser();
			    int result = chooser.showOpenDialog(zeichenbrett);

			    switch(result){

			    case JFileChooser.CANCEL_OPTION:
			    	break;

			    case JFileChooser.APPROVE_OPTION:

			    		try {
			    			String file = chooser.getSelectedFile().getPath();
			    			if (file != null) {
			    				Image img = ImageIO.read(new File(file));
			    				zeichenbrett.setStempelBild(img);
			    				zeichenbrett.setVerwendetesWerkzeug(Zeichenbrett.TOOL_STAMP);
			    			}
			    		}
			    		catch (IOException exc) {
			    			exc.printStackTrace();
			    		}
				}
			}};
		stampchoose.putValue(Action.SHORT_DESCRIPTION, "Icon,Bild,Skizze einfügen (eigene Stempelfunktion)");
		tb.add(stampchoose);


		AbstractAction colorchoose = new AbstractAction("Farben", new ImageIcon(getClass().getResource("/images/farben_neu.gif"))) {
			public void actionPerformed(ActionEvent e) {
				Color farbe = JColorChooser.showDialog(zeichenbrett, "Farbe auswählen",
						zeichenbrett.getForeground());
				zeichenbrett.setForeground(farbe);
			}
		};
		colorchoose.putValue(Action.SHORT_DESCRIPTION, "Farbe auswählen");
		tb.add(colorchoose);


		AbstractAction clear = new AbstractAction("Löschen", new ImageIcon(getClass().getResource("/images/trash.gif"))) {
			public void actionPerformed(ActionEvent e) {
				zeichenbrett.loescheZeichenflaeche();
				zeichenbrett.repaint();
			}
		};
		clear.putValue(Action.SHORT_DESCRIPTION, "Zeichenfläche löschen");
		tb.add(clear);


		AbstractAction load = new AbstractAction("Load", new ImageIcon(getClass().getResource("/images/efolder.gif"))) {
			public void actionPerformed(ActionEvent e) {

			}
		};
		load.putValue(Action.SHORT_DESCRIPTION, "Bild laden");
		tb.add(load);

		  final JFileChooser d = new JFileChooser();
	      d.setSelectedFile(new File("Bildname.png"));

		AbstractAction save = new AbstractAction("speichern", new ImageIcon(getClass().getResource("/images/diskblue.gif"))) {
			public void actionPerformed(ActionEvent e) {
				BufferedImage neuesBild = zeichenbrett.getImage();

			       //BufferedImage neuesBild = zeichenbrett.getMergedImage();
			  		           try {
			  				   		int result = d.showSaveDialog(d);

			  				   		switch(result){
			  				   			case JFileChooser.CANCEL_OPTION:
			  				   			//System.out.println("Abbrechen");
			  				   			break;

			  				   			case JFileChooser.APPROVE_OPTION:
			  				   			///System.out.println("Speichern");
			  				   			ImageIO.write(neuesBild, "PNG", new File(d.getSelectedFile().getAbsolutePath()));
			  				   			break;
			  						}
			  					}
			  				    catch (IOException e1) {
			  		               e1.printStackTrace();
			  		            }
			  		            catch(java.security.AccessControlException ace) {
			  		               JOptionPane.showMessageDialog(MalerApplet.this,
			  		                     "Das Applet ist nicht signiert!\nEs besitzt daher keine Rechte für den Zugriff auf das lokale Dateisystem",
			  		                     "java.security.AccessControlException", JOptionPane.ERROR_MESSAGE);
			  		            }


//				try {
//					ImageIO.write(neuesBild, "PNG", new File("userImage.png"));
//				} catch (IOException e1) {
//					e1.printStackTrace();
//				}
			}
		};
		save.putValue(Action.SHORT_DESCRIPTION, "Bild speichern");
		tb.add(save);


		AbstractAction ok = new AbstractAction("Send", new ImageIcon(getClass().getResource("/images/ok.gif"))) {
			public void actionPerformed(ActionEvent e) {
				int selection = JOptionPane.showConfirmDialog(MalerApplet.this,"Das gemalte Bild wird jetzt zum Server übertragen !",
						"Warnung",JOptionPane.OK_CANCEL_OPTION,JOptionPane.WARNING_MESSAGE);

						if(selection == JOptionPane.OK_OPTION){

								try{

								    int byteStream;

									BufferedImage neuesBild = zeichenbrett.getImage();

									ImageIO.write(neuesBild, "PNG", new File("userImage.png"));
									File fileRead = new File("userImage.png");


								    Socket server = new Socket(host, port);
								    FileInputStream input = new FileInputStream(fileRead);

								    DataOutputStream output = new DataOutputStream(server.getOutputStream());

								    int availableBytes = input.available();

								    while (availableBytes > 0){

								    	byteStream = input.read();
								        output.write(byteStream);
								        //output.flush();
								        availableBytes--;
								    }


									String s= url;
									URL u= new URL(s);
									getAppletContext().showDocument(u);

								}

									catch (IOException ex) {
										JOptionPane.showMessageDialog(MalerApplet.this,
									    "Übertragungsfehler: Verbindung zum Server gescheitert!" ,
										"Fehler", JOptionPane.ERROR_MESSAGE);
									}
						}
			}
		};
		ok.putValue(Action.SHORT_DESCRIPTION, "Bildvergleich starten");
		tb.add(ok);

		tb.addSeparator();
		tb.addSeparator();

		AbstractAction exit = new AbstractAction("Exit", new ImageIcon(getClass().getResource("/images/exit.gif"))) {
			public void actionPerformed(ActionEvent e) {

			}
		};
		exit.putValue(Action.SHORT_DESCRIPTION, "Malapplet verlassen");
		tb.add(exit);



		getContentPane().add(tb, BorderLayout.EAST);

	}

}
```

Klasse 2

```
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JComponent;

public class Zeichenbrett extends JComponent {

	// Die zur Verfügung stehenden Werkzeuge
	public static final int TOOL_PIXEL = 0;
	public static final int TOOL_RECTANGLE = 1;
	public static final int TOOL_CIRCLE = 2;
	public static final int TOOL_STAMP = 3;
	public static final int TOOL_FILLRECT = 4;
	public static final int TOOL_FILLOVAL = 5;
	// Das aktuell verwendete Werkzeug
	private int usedTool;
	// Dieses Bild wird gezeichnet, wenn das Werkzeug "Stempel" verwendet wird.
	private Image usedStamp;

	// Koordinaten der MousePressed-Events
	private int pressedX = 0;
	private int pressedY = 0;
	// Koordinaten der MouseReleased-Events
	private int releasedX = 0;
	private int releasedY = 0;
	// Koordinaten der MouseDragged-Events
	private int draggedX = 0;
	private int draggedY = 0;
	// Aus den Mausbewegungen errechnete Breite und Höhe
	private int width = 0;
	private int height = 0;

	// Breite des bemalbaren Bereichs
	protected static final int IMAGE_WIDTH = 600;
	// Höhe des bemalbaren Bereichs
	protected static final int IMAGE_HEIGHT = 400;
	// Auf dieses Bild wird gezeichnet
	private BufferedImage myImageBuffer;
	// Referenz auf die Zeichenfläche des Bildes.
	private Graphics2D myGraphicBuffer;
	// temporäres Bild für Animation
	private BufferedImage tempImageBuffer;
	// temporäre Zeichenfläche für Animation
	private Graphics2D tempGraphicBuffer;

	/**
	 * Initialisierung.
	 * @throws IOException
	 */
	public Zeichenbrett() throws IOException {
		// Hintzergrundfarbe setzen
		setBackground(Color.white);
		// Vordergrundfarbe (Zeichenfarbe) setzen
		setForeground(Color.red);
		// Grösse der Zeichenfläche setzen
		setPreferredSize(new Dimension(IMAGE_WIDTH, IMAGE_HEIGHT));

		// Default-Stempel
		usedStamp = ImageIO.read(new File("images/smiley-channel.gif"));
		// Default-Werkzeug
		usedTool = TOOL_PIXEL;

		// Die Bild-Buffer erzeugen
		tempImageBuffer = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_ARGB);
		this.loescheTempZeichenflaeche();
		myImageBuffer = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_ARGB);
		this.loescheZeichenflaeche();

		/*
		 * Beim Drücken der Maustaste wird eine Referenz auf die
		 * Zeichenfläche des Pufferbildes erzeugt. Anschl. wird je nach gewähltem
		 * Werkzeug zum ersten Mal auf den Puffer gezeichnet.
		 * Beim Lösen der Taste wird die Zeichenflächenreferenz wieder freigegeben.
		 */
		addMouseListener(new MouseAdapter() {
			public void mousePressed(MouseEvent mpe) {
				// Referenz auf die temporäre Zeichenfläche erzeugen
				tempGraphicBuffer = (Graphics2D) tempImageBuffer.getGraphics();
				// Referenz auf die Zeichenfläche erzeugen
				myGraphicBuffer = (Graphics2D) myImageBuffer.getGraphics();

				/*
				 * ACHTUNG!!! nicht ausserhalb der Grenzen des Pufferbildes zeichnen!
				 */
				pressedX = mpe.getX();
				if (pressedX>=IMAGE_WIDTH) pressedX=IMAGE_WIDTH-1;
				if (pressedX<0) pressedX=0;
				pressedY = mpe.getY();
				if (pressedY>=IMAGE_HEIGHT) pressedY=IMAGE_HEIGHT-1;
				if (pressedY<0) pressedY=0;

				switch (usedTool) {
					case TOOL_PIXEL:
						myImageBuffer.setRGB(pressedX, pressedY, getForeground().getRGB());
						break;
					case TOOL_RECTANGLE:
						myGraphicBuffer.setColor(getForeground());
						myGraphicBuffer.fillRect(pressedX-5, pressedY-5, 10, 10);
						break;
					case TOOL_CIRCLE:
						myGraphicBuffer.setColor(getForeground());
						myGraphicBuffer.fillOval(pressedX-5, pressedY-5, 10, 10);
						break;
					case TOOL_STAMP:
						int w = usedStamp.getWidth(Zeichenbrett.this);
						int h = usedStamp.getHeight(Zeichenbrett.this);
						myGraphicBuffer.drawImage(usedStamp, pressedX-w/2, pressedY-h/2, Zeichenbrett.this);
						break;
					case TOOL_FILLRECT:
					case TOOL_FILLOVAL:
						break;
				}
				// Komponente neu zeichnen!!!!
				repaint();
			}

			public void mouseReleased(MouseEvent mre) {
				/*
				 * ACHTUNG!!! nicht ausserhalb der Grenzen des Pufferbildes zeichnen!
				 */
				releasedX = mre.getX();
				if (releasedX>=IMAGE_WIDTH) releasedX=IMAGE_WIDTH-1; if (releasedX<0) releasedX=0;
				releasedY = mre.getY();
				if (releasedY>=IMAGE_HEIGHT) releasedY=IMAGE_HEIGHT-1; if (releasedY<0) releasedY=0;

				int x = 0;
				int y = 0;
				if ( releasedX < pressedX ) {
					x = releasedX;
					width = pressedX - releasedX;
				} else {
					x = pressedX;
					width = releasedX - pressedX;
				}
				if ( releasedY < pressedY ) {
					y = releasedY;
					height = pressedY - releasedY;
				} else {
					y = pressedY;
					height = releasedY - pressedY;
				}

				loescheTempZeichenflaeche();

				switch (usedTool) {
					case TOOL_FILLRECT:
						myGraphicBuffer.setColor(getForeground());
						myGraphicBuffer.fillRect(x, y, width, height);
						break;
					case TOOL_FILLOVAL:
						myGraphicBuffer.setColor(getForeground());
						myGraphicBuffer.fillOval(x, y, width, height);
						break;
				}
				// Komponente neu zeichnen!!!!
				repaint();
				// Referenzen auf die Zeichenflächen freigeben
				if (myGraphicBuffer != null) {
					myGraphicBuffer.dispose();
					myGraphicBuffer = null;
				}
				if (tempGraphicBuffer != null) {
					tempGraphicBuffer.dispose();
					tempGraphicBuffer = null;
				}
			}
		});

		/*
		 * Zeichnet in Abhängigkeit zu dem verwendeten Werkzeug auf das Pufferbild.
		 */
		addMouseMotionListener(new MouseMotionAdapter() {
			public void mouseDragged(MouseEvent mde) {
				/*
				 * ACHTUNG!!! nicht ausserhalb der Grenzen des Pufferbildes zeichnen!
				 */
				draggedX = mde.getX();
				if (draggedX>=IMAGE_WIDTH) draggedX=IMAGE_WIDTH-1; if (draggedX<0) draggedX=0;
				draggedY = mde.getY();
				if (draggedY>=IMAGE_HEIGHT) draggedY=IMAGE_HEIGHT-1; if (draggedY<0) draggedY=0;

				int x = 0;
				int y = 0;
				if ( draggedX < pressedX ) {
					x = draggedX;
					width = pressedX - draggedX;
				} else {
					x = pressedX;
					width = draggedX - pressedX;
				}
				if ( draggedY < pressedY ) {
					y = draggedY;
					height = pressedY - draggedY;
				} else {
					y = pressedY;
					height = draggedY - pressedY;
				}

				switch (usedTool) {
					// einen Pixel manipulieren
					case TOOL_PIXEL:
						myImageBuffer.setRGB(draggedX, draggedY, getForeground().getRGB());
						break;
					// Rechteck der Grösse 10x10 um die Mausposition herum malen
					case TOOL_RECTANGLE:
						myGraphicBuffer.setColor(getForeground());
						myGraphicBuffer.fillRect(draggedX-5, draggedY-5, 10, 10);
						break;
					// Kreis der Grösse 10x10 um die Mausposition herum malen
					case TOOL_CIRCLE:
						myGraphicBuffer.setColor(getForeground());
						myGraphicBuffer.fillOval(draggedX-5, draggedY-5, 10, 10);
						break;
					// ein Bild (*.png) malen
					case TOOL_STAMP:
						int w = usedStamp.getWidth(Zeichenbrett.this);
						int h = usedStamp.getHeight(Zeichenbrett.this);
						myGraphicBuffer.drawImage(usedStamp, draggedX-w/2, draggedY-h/2, Zeichenbrett.this);
						break;
					case TOOL_FILLRECT:
						loescheTempZeichenflaeche();
						tempGraphicBuffer.setColor(getForeground());
						tempGraphicBuffer.fillRect(x, y, width, height);
						break;
					case TOOL_FILLOVAL:
						loescheTempZeichenflaeche();
						tempGraphicBuffer.setColor(getForeground());
						tempGraphicBuffer.fillOval(x, y, width, height);
						break;
				}
				// Komponente neu zeichnen!!!!
				repaint();
			}
		});
	}

	/**
	 * Erzeugt neuen Bildbuffer
	 */
	public void loescheZeichenflaeche() {
		myImageBuffer = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_ARGB);
	}

	/**
	 * übermalt den temporären Bildbuffer
	 */
	public void loescheTempZeichenflaeche() {
		tempGraphicBuffer = (Graphics2D) tempImageBuffer.getGraphics();
		tempGraphicBuffer.setColor(getBackground());
		tempGraphicBuffer.fillRect(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);
	}

	/**
	 * Überschreibt die geerbte Methode und zeichnet lediglich das Pufferbild
	 * und das temporäre Bild auf den Bildschirm.
	 */
	public void paintComponent(Graphics g) {
		if (tempImageBuffer!=null)
			g.drawImage(tempImageBuffer, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, this);
		g.drawImage(myImageBuffer, 0, 0, this);
	}

	public int getVerwendetesWerkzeug() {
		return usedTool;
	}

	public void setVerwendetesWerkzeug(int verwendetesWerkzeug) {
		switch (verwendetesWerkzeug) {
			case TOOL_PIXEL:
			case TOOL_RECTANGLE:
			case TOOL_CIRCLE:
			case TOOL_STAMP:
			case TOOL_FILLRECT:
			case TOOL_FILLOVAL:
				usedTool = verwendetesWerkzeug;
		}
	}

	public void setStempelBild(Image img) {
		usedStamp = img;
	}

	public BufferedImage getImage() {
		return myImageBuffer;
	}
}
```


----------



## Gast (22. Mai 2006)

Es hat sich nun Gott sei Dank erledigt !!!!

In der zweiten klasse musste ich noch an einer Stelle das setzen der Referenz korrigieren.

Danke nochmal an Wildcard   :toll:


----------

