Noch mehr Java gibts auf www.javahochzwei.de

Eigener Splashscreen

Moin!
Heute hab ich mich mal an das Thema „Splashscreen in Java“ rangesetzt und möchte Euch dieses Thema hiermit mal näher bringen.

Zuerst mal die Frage: Was ist ein Splashscreen?

Ein Splashscreen ist eine Art Startbildschirm. Man kennt sie von so gut wie allen Programmen: Startet man ein Programm, wird erst einmal ein Bild angezeigt und das Programm lädt im Hintergrund. Ist es dann geladen, wird es angezeigt.

Wie füge ich diesen in mein Programm ein?
Dies ist ein bisschen verwirrend. ;) Man kann in seinem Programm nicht einfach Code à la

SplashScreen splash = new SplashScreen("test.jpg");

benutzen, um den gewünschten Effekt zu erzielen. Man muss dem Programm beim Starten „sagen“, dass man einen SplashScreen haben möchte!

Hierzu gibt es zwei Möglichkeiten:

  • 1. Mit einem zusätlichen Parameter in der Kommandozeile
  • 2. Mit Hilfe der Manifest für ein jar-File

zu 1)
Möchte ich mein .class-File (z.B. MeinProgrammInit.class) über die Kommandozeile starten und diesem aber ein Splashscreen „mitgeben“, muss ich folgende Schritte ausführen: http://docs.oracle.com/javase/tutorial/uiswing/misc/splashscreen.html#cl

zu 2)
Habe ich allerdings mein Programm schon als .jar-File gepackt und möchte diesem einen SplashScreen „mitgeben“, so muss man folgende Schritte durchführen: http://docs.oracle.com/javase/tutorial/uiswing/misc/splashscreen.html#jar

Soweit so gut.. Kommen wir jetzt aber mal zum Quelltext!

/**
	 * eigene Methode, die den SplashScreen initialisiert und ihn anzeigt!
	 */
	private void splashScreen() {

		// hier holt sich das Programm den entsprechenden SplashScreen, den wir
		// entweder in der Kommandozeile (1.) oder in der Manifest (2.)
		// festgelegt haben
		SplashScreen splash = SplashScreen.getSplashScreen();

		if (splash == null) {

			// hier kommt er nur hin, wenn kein SplashScreen gesetzt wurde!
			System.out.println("SplashScreen ist null!");
		} else {

			// wenn wir hier sind, dann wurde ein Splashscreen gesetzt!

			// Zitat API: "Creates a graphics context (as a Graphics2D object)
			// for the splash screen overlay image, which allows you to draw
			// over the splash screen."
			// -> sollte klar sein...
			// das ist immer der Text à la "Loading Package Foo" etc., der auf dem 
			// SplashScreen angezeigt wird
			Graphics2D g = splash.createGraphics();

			if (g == null) {
				System.out.println("g ist null!");
			} else {

				for (int i = 0; i < 100; i++) {

					// eigene Methode!
					renderSplashFrame(g, i);

					// redert den SplashScreen neu!
					// API: "Updates the splash window with current contents of the overlay image."
					splash.update();

					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}

			// okay, Programm ist geladen.. Schließe den SplashScreen!
			// API: "Hides the splash screen, closes the window, and releases all associated resources."
			splash.close();
		}
	}

Haben wir entweder wie in 1. oder in 2. beschrieben, unserem Programm angekündigt, dass wir einen SplashScreen haben wollen, müssen wir diesen natürlich noch in unserem Programm „einbauen“.
Einen Beispielcode seht ihr oben! Ich habe ihn mal ausreichend auskommentiert, so dass die einzelnen Schritte alle klar sein sollten!

Nun fehlt aber noch die eigene Methode „renderSplashFrame(int, int)“:

	static void renderSplashFrame(Graphics2D g, int frame) {
		final String[] comps = { "Element1", "Element2", "Element3", "Element4" };

		g.setComposite(AlphaComposite.Clear);

		g.fillRect(120, 255, 200, 40);

		g.setPaintMode();
		g.setColor(Color.WHITE);
		g.drawString("Loading " + comps[(frame / 5) % 4] + "...", 190, 290);
	}

Die ist recht einfach zu erklären:
Wir legen ein String-Array „comps“ an. Das sind die Strings, die angezeigt werden sollen.
Das g.fillRect(…,…,…,…) spannt ein Rechteck auf. Dieses ist dafür zuständig den jeweils zuvor angezeigten String zu elemenieren, sprich das nach „Loading Element1…“ das „Loading Element2…“ richtig angezeigt wird. Benutzt man nicht die Methode g.fillRect(…), dann überlagern sich die beiden oben genannten Strings!!
Die Zahlen bei g.fillRect und g.drawString geben die jeweilige Position an, wo genau das Rechteck, bzw. der Text gezeichnet werden soll. Spielt man hiermit ein bisschen rum, kommt man schnell auf das gewünschte Ergebnis!

Es geht zwar aus dem oben aufgeführten Quelltext hervor, aber ich möchte es dennoch erwähnen. Das Graphics2D Objekt mit dem Namen g in der Methode renderSplashFrame muss das Graphics2D-Object sein, das wir mit Hilfe von splash.createGraphics gewonnen haben! Denn nur dieses kann „über“ den SplashScreen zeichnen!!

Wenn alles klappt, dann müsste es so aussehen:

Am Schluss noch weiterführende Links zu dem Thema:
Tutorial von Oracle zum Thema
Java API zu SplashScreen

Hier gibts noch den Quelltext mit der ganzen Klassen und dem Bild:

  OwnSplashScreen.rar (61,5 KiB, 70 hits)

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.