# Splash Screen



## bjmicha (20. Februar 2004)

Hallo,

ich würde gerne für meine Anwendung eine Art Splash Screen machen. Ich will einfach bevor das Programm gestartet wird 3 sekunden lang oder so ein image anzeigen lassen.
Ich brauche also keine komplizierten Klassen die den Splash Screen so lange anzeigen bis die Anwendung geladen ist oder so. Es geht einfach nur darum 3 sekunden lang ein image anzuzeigen.

Gruß

Michael


----------



## Peter Bönnen (20. Februar 2004)

Mal eben quick'n'dirty:

```
// SplashScreen.java

import java.awt.Graphics;
import java.awt.Image;

import javax.swing.JWindow;

public class SplashScreen extends JWindow implements Runnable
{
	public void run()
	{
		setSize(400, 110);
		setLocationRelativeTo(null);
		setVisible(true);
		
		try
		{
			Thread.sleep(3000);
		}
		catch (InterruptedException e)
		{
			dispose();
		}
		dispose();	
	}
	
	public void paint(Graphics g)
	{
		Image splashImage = getToolkit().getImage("h:/h-ff-dl.png");
		g.drawImage(splashImage, 0, 0, this); 
	}
}
```
Das ist der eigentliche SplashScreen. Lässt sich natürlich noch verbessern. Gestartet wird dieser dann z.B. am Anfang deiner Hauptklasse über:

```
Thread splashThread = new Thread(new SplashScreen());
splashThread.start();
```


----------



## Thomas Darimont (20. Februar 2004)

Hi!


```
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Toolkit;
import java.io.File;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

/*
 * Created on 20.02.2004
 *
 * To change the template for this generated file go to
 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
 */

/**
 * @author Darimont
 *
 * To change the template for this generated type comment go to
 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
 */
public class SplashScreen extends JFrame {

	private Image img;
	private int x, y;

	private Timer timer;

	public SplashScreen(File pic, int x, int y, long millis) {

		this.x = x;
		this.y = y;
		setSize(x, y);

		Dimension d = Toolkit.getDefaultToolkit().getScreenSize();

		setLocation(d.width / 2 - x / 2, d.height / 2 - y / 2);

		this.setUndecorated(true);

		MediaTracker mt = new MediaTracker(this);
		try {

			img = ImageIO.read(pic).getScaledInstance(x, y, Image.SCALE_SMOOTH);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			//e.printStackTrace();
			System.err.println("Konnte Datei nicht öffnen!");
		}
		setVisible(true);

		if (img == null)
			img = this.createImage(x, y);

		
		mt.addImage(img, 0);

		try {
			mt.waitForAll();
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		
		timer = new Timer();
		timer.schedule(new ExitSplashTask(this), millis);
		
	}

	public static void main(String[] args) {
		// Zeig mir das Bild c:\energy.jpg in der Größe 240,180, für 5 Sekunden an.
		SplashScreen screen =
			new SplashScreen(new File("c:/energy.jpg"), 240, 180, 5000);
	}

	public void paint(Graphics g) {
		super.paint(g);
		if (img != null)
			g.drawImage(img, 0, 0, this);
	}

	class ExitSplashTask extends TimerTask {

		private JFrame frm;

		public ExitSplashTask(JFrame frm) {
			this.frm = frm;
		}
		/* (non-Javadoc)
		 * @see java.util.TimerTask#run()
		 */
		public void run() {
			// TODO Auto-generated method stub
			frm.setVisible(false);
			frm.dispose();
			/* 
			 * Dieser Aufruf beendet hier die VM!
			 * Hier würde also normalerweise entweder die Klasse des Hauptprogramms
			 * 
			 */
			System.exit(0);
		}

	}
}
```

Gruß Tom


----------



## bjmicha (20. Februar 2004)

Hallo Fluke,

vielen dank.....
es klappt soweit nur das ich nicht weiss wie ich dir paint methode aufrufen soll 
Was muss ich machend damit das bild auch angezeigt wird Was muss ich genau der paint methode als Graphics objekt übergeben?

Tausend Dank

Michael


----------



## Peter Bönnen (20. Februar 2004)

Bei meiner wie gesagt schnellen und im Prinzip recht unsauberen Lösung, ersetzt du einfach "h:/h-ff-dl.png" durch den Dateinamen deines Bildes und passt setSize(400, 110); an dessen Größe an. Dann den zweiten Code z.B. in die main Methode deiner Hauptklasse und das war's. die paint() Methode rufst du nicht auf, die wird automatisch beim setVisible(true); zum Zeichen des JWindow aufgerufen. Die paint(Graphics g); Methode ist  eine Methode der Klasse Component (von der JWindow über ein paar andere Klassen hinweg abgeleitet ist) und wird hier nur überschrieben.

Das sollte auch mehr ein Denkansatz sein. Keine Ahnung, wie gängige SplashScreen Implementierungen aussehen. Hab für mich noch nie einen geschrieben.

Peter


----------



## Thomas Darimont (20. Februar 2004)

*Transparenter Splashscreen*

Hi!


```
import java.awt.AWTException;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.io.File;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.JFrame;
/*
 * Created on 20.02.2004
 * 
 * To change the template for this generated file go to Window - Preferences -
 * Java - Code Generation - Code and Comments
 */
/**
 * @author Administrator
 * 
 * To change the template for this generated type comment go to Window -
 * Preferences - Java - Code Generation - Code and Comments
 */
public class CoolSplash extends JFrame {
	private int defaultScreenWidthMargin = 50;
	private int defaultScreenHeightMargin = 37;
	private Image capture;
	private Image picture;
	private Timer timer;
	/**
	 * @param file
	 */
	public CoolSplash(File file, int w, int h, long millis) {
		int newW = w + defaultScreenWidthMargin;
		int newH = h + defaultScreenHeightMargin;
		setSize(newH, newH);
		setUndecorated(true);
		Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
		int frmX = ((int) d.getWidth() - (w + defaultScreenWidthMargin)) / 2;
		int frmY = ((int) d.getHeight() - (h + defaultScreenHeightMargin)) / 2;
		setLocation(frmX, frmY);
		try {
			Robot rob = new Robot();
			Rectangle rect = new Rectangle(frmX, frmY, newW, newH);
			capture = rob.createScreenCapture(rect);
		} catch (AWTException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		MediaTracker mt = new MediaTracker(this);
		try {
			picture = Toolkit.getDefaultToolkit().getImage(file.toURL())
					.getScaledInstance(w, h, Image.SCALE_SMOOTH);
			//ImageIO.read(file).getScaledInstance(w, h,Image.SCALE_SMOOTH);
			mt.addImage(picture, 0);
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		try {
			mt.waitForAll();
		} catch (InterruptedException e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		}
		setVisible(true);
		if (picture == null)
			picture = createImage(w, h);
		timer = new Timer();
		timer.schedule(new ExitTimerTask(this), millis);
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		new CoolSplash(new File("c:/Test.gif"), 400, 300, 5000l);
	}
	public void paint(Graphics g) {
		if (picture != null && capture != null) {
			capture.getGraphics().drawImage(picture,
					0 + defaultScreenWidthMargin / 2,
					0 + defaultScreenHeightMargin / 2, this);
			g.drawImage(capture, 0, 0, this);
		}
	}
	class ExitTimerTask extends TimerTask {
		private JFrame frm;
		public ExitTimerTask(JFrame frm) {
			this.frm = frm;
		}
		/*
		 * (non-Javadoc)
		 * 
		 * @see java.util.TimerTask#run()
		 */
		public void run() {
			// TODO Auto-generated method stub
			frm.setVisible(false);
			frm.dispose();
			System.exit(0);
		}
	}
}
```

Anbei test.gif

Gruß Tom


----------



## sportingt (13. Oktober 2004)

Verfolge schon eine Weile diese ganze Geschichte. Frage mich nur immer warum bei den Beispielcodes ein eigener Thread erzeugt wird. 
Frame/Window wird eingeblendet ausgeblendet, aber java.exe wird totzdem nicht beendet. Das Swing-Object bleibt im Hintergrund noch immer erhalten.
Da diese Operation nicht ganz so performant ist, könnte man doch einfach am Anfang des Main-Codes den Frame einblenden, Thread.sleep(), dann ausblenden.
Warum läuft nicht der Thread mit dem Frame ab, beendet sich, und parallel der Main-Code? Wenn man kein System.exit(0) gibt,  hat man hinterher für jeden vergessenen Thread ein java.exe Prozess im System!?


----------



## Thomas Darimont (13. Oktober 2004)

Hallo!

Von welcher Implementierung sprichst du denn jetzt? Wie du schon richtig erkannt hast verwende ich einen Thread um den JFrame nach einer gewissen Anzahl von Sekunden zu auszublenden.
Wenn du kein System.exit(...) aufrufst bleibt der Java Prozess so lange erhalten bis der letzte Thread gestorben ist. Das ist jedoch nie der Fall, da in meinem Beispiel bei auslassen des System.exit(..)-Aufrufs der JFrame zwar ausgeblendet das dazugehörige Swing Thread Paket (Event Threads etc.) jedoch nicht stribt sondern einfach weiter läuft.
So ist's aber im Normalfall auch gedacht, denn die Anwendung soll ja nach dem Splashscreen auch noch weiter laufen...  (natürlich ohne System.exit(...) aufzurufen).

Gruß Tom


----------



## Snape (19. Oktober 2004)

Moin,
wenn ich einhaken darf:
Ich hätte nun gern ähnliches, komme aber nicht auf die zündende Idee.
Wenn ich nach dem SplashScreen (JFrame/JDialog, egal) ein ganz normales JFrame in der Ansicht haben möchte, wo und wie baue ich das in den beiden obigen Beispielcodes ein? Bei diesem Code hier von Peter:

```
Thread splashThread = new Thread(new SplashScreenTest());
    splashThread.start();
    while ( splashThread.isAlive() )
    {
      // do nothing
    }
    new XPInstall().show(); // mein Frame, der danach angezeigt werden soll
```
wird nur der Rahmen des Bildes angezeigt, nicht das Bild selbst. Lasse ich die while-Schleife weg, wird das Bild angezeigt, aber auch unverzüglich mein Frame geöffnet. Vermutlich sehe ich den Wald vor lauter Bäumen nicht.


----------



## Thomas Darimont (19. Oktober 2004)

Hallo!

Suchst du vielleicht sowas?

SplashScreen:

```
package de.tutorials;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

public class SplashScreen extends JFrame {
	private static final long serialVersionUID = 5654240689518773770L;

	private BufferedImage image;

	private int w, h, x, y;

	public SplashScreen(File file) {
		super("SplashScreen");
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setUndecorated(true);
		try {
			image = ImageIO.read(file);
			w = image.getWidth();
			h = image.getHeight();

			Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
			x = (d.width - w) / 2;
			y = (d.height - h) / 2;

		} catch (IOException e) {
			e.printStackTrace();
		}
		setSize(w, h);
		setLocation(x,y);
	}

	public void display(long l) {
		setVisible(true);
		Timer timer = new Timer();
		timer.schedule(new TimerTask(){
			public void run() {
				dispose();
			}},l);
		
	}

	public void paint(Graphics g) {
		super.paint(g);
		g.drawImage(image, 0, 0, this);
	}
}
```

Main:

```
package de.tutorials;

import java.io.File;

import javax.swing.JFrame;

public class Main extends JFrame {

	private static final long serialVersionUID = 2805838986152348164L;

	public Main() {
		super("Main");
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setSize(640, 480);
	}

	public static void main(String[] args) {
		new Main().start();
	}

	private void start() {
		SplashScreen ss = new SplashScreen(new File("c:/Beispiel.jpg"));
		ss.display(5000L);
		while (ss.isDisplayable()) {
			try {
				Thread.sleep(100L);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		setVisible(true);
	}
}
```

HTH
Gruß Tom


----------



## Snape (19. Oktober 2004)

Hi,
probier ich grad mal nicht aus. Aber kurz nach meiner Frage habe ich etwas bemerkt in dem ersten Code von Dir:


```
class ExitSplashTask extends TimerTask {

		private JFrame frm;

		public ExitSplashTask(JFrame frm) {
			this.frm = frm;
		}
		/* (non-Javadoc)
		 * @see java.util.TimerTask#run()
		 */
		public void run() {
			// TODO Auto-generated method stub
			frm.setVisible(false);
			frm.dispose();
			/* 
			 * Dieser Aufruf beendet hier die VM!
			 * Hier würde also normalerweise entweder die Klasse des Hauptprogramms
			 * 
			 */
			System.exit(0);
		}

	}
```

Hätte ich verstanden bzw. sorgsam gelesen, was da steht, kann man problemlos an Stelle des System.exit(0); einen eigenen Frame konstruieren und aufrufen. 
So geht es erst einmal. Interessant wäre die Frage nach verschiedenen SplashScreens
Und mich würde interessieren, warum das System.exit(0); erst aufgerufen wird, wenn die Zeit abgelaufen ist. Erklär mal.


----------



## Thomas Darimont (19. Oktober 2004)

Hallo!



> Und mich würde interessieren, warum das System.exit(0); erst aufgerufen wird, wenn die Zeit abgelaufen ist. Erklär mal.


Hmmm?

Weil die run() Methode des TimerTasks erst aufgerufen wird wenn die 5 Sekunden um sind.

Gruß Tom


----------



## Snape (19. Oktober 2004)

*Ditsch*
Warum ist die Banane krum? Weil sie krumm ist. ;-P
Also noch einmal:
Warum wird die run()-Methode erst aufgerufen, wenn die Zeit (=5 Sekunden in dem Beispiel) abgelaufen ist?


----------



## Thomas Darimont (19. Oktober 2004)

Hallo!


```
/* Hier wird einer neuer Timer instanziert ... gleichzeitig wird "intern"
		 * ein neuer Thread gestartet der für die Ausführung zukünftiger TimerTasks 
		 * bzw. genauer gesagt deren run() Methode zuständig ist. Zu diesem Zweck überprüft  
		 * dieser Thread immer die interne TaskQueue nach TimerTasks die ausgeführt 
		 * werden wollen und wartet natürlich bei einer leeren TaskQueue.
		 * Findet der Thread einen TimerTask wartet er die im TimerTask angegebene Zeit ab
		 * und ruft dann die dort definierte run() Methode auf.
		 */
		Timer timer = new Timer();
		//Hier wird eben ein solcher TimerTask erzeugt und in die interne TimerQueue aufgenommen
		timer.schedule(new TimerTask(){
			public void run() {
				dispose();
			}},l);
		//Siehe dazu sources von java.util.Timer, java.util.TimerTask, java.util.TaskQueue, java.util.TimerThread und ff
```

M.a.W.: 
Weil die run() Methode des TimerTasks erst aufgerufen wird wenn die 5 Sekunden um sind. ;-)

Gruß Tom


----------



## Thomas Darimont (21. Oktober 2004)

Alternatives starten der Hauptanwendung mittels Reflection...:


```
/*
 * Created on 21.10.2004
 */
package de.tutorials;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Timer;
import java.util.TimerTask;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

/**
 * @author Darimont
 *  
 */
public class SplashScreen extends JFrame {

    private static final long serialVersionUID = -8617628157371474745L;

    BufferedImage image;

    int w, h;

public SplashScreen(final String file, final long ms, final Method target) {
        super();
        setUndecorated(true);
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        try {
            image = ImageIO.read(new File(file));
        } catch (IOException e) {
            e.printStackTrace();
        }
        w = image.getWidth();
        h =image.getHeight();
        Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
        setSize(w,h);
        setLocation((d.width - w)/2,(d.height-h)/2);
        
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            public void run() {
                try {
                    dispose();
                    image = null;
                    target.invoke(null, new Object[1]);
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }, ms);
        
        setVisible(true);
    }    public void paint(Graphics g) {
        super.paint(g);
        g.drawImage(image, 0, 0, this);
    }

    public static void main(String[] args) {
        try {
            //Datei energy.jpg als Bildanzeigen,
            // 5000ms -> 5s warten
            // main-Methode der Klasse de.tutorials.Main ausführen...
            new SplashScreen("C:/energy.jpg", 5000L, Class.forName(
                    "de.tutorials.Main").getMethod("main",
                    new Class[] { String[].class }));
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
```

Gruß Tom


----------



## TheYak (28. März 2005)

Hallo,
habe eben durch Zufall diesen Thread gefunden und auch gleich den Code für einen pseudotransparenten Splashscreen ausprobiert. Allerdings ist mir aufgefallen, dass das Bild welches übergeben wird in der rechten unteren Ecke des Rechtecks plaziert wird, welches den Screenshot des Desktops beinhaltet.
Starte ich (oder ein User) also ein Programm welches einen Splashscreen zaubert und minimiere dann ein dahinter liegendes Programm, so tritt folgender Effekt auf.
Liegt z.b. auf dem Desktop eine Verknüpfung zum Programm und man öffnet darüber das Programm, wird der Splashscreen ja sofort fokusiert wodurch dann, wenn die Verknüpfung ungünstig liegt, ein Teil des Verknüpfungsicons hell und der andere Dunkel ist.
Wie kann ich das Feld welches den Screenshot beinhaltet verkleinern ? Jegliche Versuche meinerseits scheiterten, weil ich dann mein Splashbild aus dem sichtbaren Bereich geschoben habe oder aber der Splash nur in einer Auflösung wirklich zentriert war.

mfg TheYak 

*btw.* erster Post hier im Forum


----------



## Thomas Darimont (28. März 2005)

Hallo!

Also dieser Splashscreen ist ja gerade deshalb transparent, weil vor dem Anzeigen ein Screenshot vom "Desktop" gemacht und das eigentliche Bild darauf gezeichnet wird. Dies erweckt dann den "Anschein" eines Tansaprenten Splashscreens. Wenn du in der zwischen Zeit natürlich den Hintergrund veränderst während das Splash-Fenster im Vordergrund wandelt kommt es zu dem von dir beobachteten Effekt.

Verändern kannst du den Gecaptured-ten Desktop Bereich mittels:

```
Rectangle rect = new Rectangle(frmX, frmY, newW, newH);
			capture = rob.createScreenCapture(rect);
```

Die Anmerkungen beziehen sich übrigens auf Post Nr.: 3



> *btw.* erster Post hier im Forum


Willkommen an Board 

Gruß Tom


----------



## TheYak (28. März 2005)

Hallo,
erstmal ein herzliches Dankeschön für die nette Begrüßung. 

Wenn ich das richtig verstehe geben doch frmX und frmY die linke obere Ecke des "Screenshots" an und newW und newH die Ausmaße des Screenshots.
Nun schaffe ich es allerdings nicht, den Screenshotbereich auf folgende Größe zu reduzieren: *klick*. Dadurch würde es optisch schöner aussiehen wenn man ein dahinterliegendes Fenster minimieren würde.
Ändere ich nun die o.g. Variablen so schiebe ich das Fenster entweder aus der Zentrierung in der Mitte des Bildschirmes oder aber mein Splashbild verschwindet oder ist nur zum Teil sichtbar.
Es kann allerdings auch sein das ich gerade auf dem Schlauch stehe, weil ich seit 3 Stunden versuche das Fenster zu verkleinern.

mfg TheYak


----------



## TheYak (28. März 2005)

Ok,
habs doch noch hinbekommen. Musste marginwidth und height verändern sowie einige andere variablen 

gruß TheYak


----------



## jensebluemchen (5. Juni 2005)

Hallo Tom,

erstmal danke für deinen netten Post mit dem "CoolSplash"! 
Ich habe versucht das ganze ein wenig weiterzuspinnen und möchte mir jetzt eine kleine Anwendung zusammenbasteln, die mit dieser Technik ein transparentes Fenster vortäuscht.

Ich habe mir also ein transparentes Bild erstellt, die Methode initBackgroundImage (entspricht im wesentlichen dem Konstruktor aus deinem Bsp.-code) aufgerufen und somit mein "transparentes" Hintergrundbild gesetzt:


```
this.getContentPane().setLayout(null); 
bgImage = new File("Test.png"); 
initBackgroundImage(bgImage,600,600);
```

Funktioniert soweit alles wunderbar, aber jetzt muss ich, wenn ich das Fenster verschiebe, minimiere, etc. das Fenster ja wieder neu zeichnen, D.h. ich muss also wieder die Methode initBackgroundImage(...) aufrufen um den "transparenten" Hintergrund zu refreshen. Ich dachte mir ... kein Problem ... in der paint-Methode aufrufen und gut ist:


```
public void paint(Graphics g) {
       initBackgroundImage(...);	
       if (picture != null && capture != null) {
			capture.getGraphics().drawImage(picture,
					0 + defaultScreenWidthMargin / 2,
					0 + defaultScreenHeightMargin / 2, this);
			g.drawImage(capture, 0, 0, this);
		}
	}
```

Das Problem dabei ist, dass ich jetzt keinen Screenshot mehr vom Desktopbereich unterhalb von meinem Fenster machen kann, sondern der Bereich, welcher transparent dargestellt werden sollte auf einmal nur als grau erscheint (mein Fenster erscheint im Screenshot also grau)!
Weiss jemand eine Lösung wie ich dieses Problem angehen kann?

Schonmal vielen Dank ...
Grüssle Jens


----------



## jensebluemchen (6. Juni 2005)

Na, hat hier niemand eine Idee?


----------



## Angiii (3. Juli 2009)

Hallo,

ich weiß der Threat ist schon ein "bisschen " älter, aber wie gute Weine...ach was solls.

Ich habe eine Frage zum transparenten SplashScreen von Thomas Darimont. Solange ich den Code so ausführe wie er auch hiersteht, funktioniert er einwandfrei. Sieht richtig Klasse aus ;-).

Nun will ich aber mein eigenes Bild einbinden und das Ganze dann in ein Jar packen. Irgendwie ist der im Programm verwendete MediaTracker mit meinen Pfadangaben jedoch nicht ganz einverstanden. So siehts im Original aus:


```
public static void main(String[] args) {
		new CoolSplash(new File("c:/Test.gif"), 400, 300, 5000l);
}
```

Statt dem "c:/Test.gif" will ich nun einen Verweis innerhalb meines späteren JARs machen. Also sowas wie:

```
public static void main(String[] args) {
		new CoolSplash(new File("/img/Test.gif"), 400, 300, 5000l);
}
```
Leider wir nach erstellen des JARs das Bild nie angezeigt. Woran kann das liegen?

Danke schonmal!


----------



## Angiii (6. Juli 2009)

Hallo,

bin doch noch selbst drauf gekommen. 

Ich lade statt einem File bei


```
public static void main(String[] args) {
		new CoolSplash(new File("c:/Test.gif"), 400, 300, 5000l);
}
```

ein ImageIcon. Dann klappts auch mit dem JAR.


----------

