Nach dem Öffnen des Dialogs eine Aktion ausführen.

B

beastofchaos

Bekanntes Mitglied
Hallo Leute,
Ich dachte ich schreibe mal für die ganzen komplexen Vorgänge in meinem Programm einen Dialog, welcher ein Laden-GIF-Icon anzeigt während die Aktion getätigt wird.
Die Aktion an sich soll einfach über ein Runnable-Objekt beim Öffnen des Dialogs ausgeführt werden.
Mein Dialog stamtm wie gewohnt von JDialog ab und enthält die beiden Attribute "labelLoad" und "iconLoading", um einen Text und zweitens das GIF-Icon anzuzeigen.

Um unnötig viele Dialog zu verhindern hab ich den Konstruktor privat definiert, eine private statische Instanz hinzugefügt und veranlasst, dass der Dialog nur erzeugt werden kann, wenn sich die Attribute "owner" und "title" zur alten Instanz unterschiedlich sind.

Java: 
public static void createDialogInstane(JFrame owner, String title)
	{
		if (instance == null || !instance.getOwner().equals(owner)
				|| !instance.getTitle().equals(title))
		{
			instance = new DLoad(owner, title);
		}
	}

Der Dialog wird dann mit dem Inhalt des Labels und dem Runnable-Objekt geöffnet
Java: 
public static void showDialog(String loadMessage, Runnable runnableAction)
	{
		if (instance == null)
		{
			throw new NullPointerException(
					"Dialog instance has to be created before trying open it!");
		}
		else
		{
			instance.runnableAction = runnableAction;
			instance.labelLoad.setText("<html>" + loadMessage + "<br>&nbsp;</html>");

			instance.setVisible(true);
		}
	}

Im Konstruktor meines Dialogs wird ein WindowListener hinzugefügt über den in "windowOpened" die Run-Methode ausgeführt wird und anschließend der Dialog wieder geschlossen wird.

Wenn ich den Spaß jetzt nutzen will, wird beim ersten Mal die GIF nicht angezeigt, aber der Dialog wird zum Glück nach ein paar Sekunden geschlossen(wenn die Aktion durchgeführt ist). Wenn ich die gleiche Aktion nochmal ausführen will, wird der Dialog geöffnet und diesmal wird die GIF angezeigt, aber der Dialog schließt sich nicht mehr. Beide Male wird dieselbe Instanz benutzt

Problem 1 -> Beim ersten Aufruf scheint die Anzeige einer GIF im Label nicht zu funktionieren
Problem 2 -> Bei allen weiteren wird der WindowListener nicht mehr aufgerufen.

Idee zu 1. -> repaint()-Methode nach dem Konstruieren direkt aufrufen -> kein Effekt
Idee zu 2. -> "windowOpened" wird nur aufgerufen, wenn der Dialog zum ersten Mal geöffnet wird.

Habt ihr zu den beiden Problemen eine Idee, die ich ausprobieren könnte?

Es muss ja nicht über den WindowListener laufen. Bloß wie könnte ich sonst eine Aktion nach dem Aufruf von "setVisible(true)" ausführen. Schließlich blockt "setVisible(true)" bei einem Dialog diesen Thread.

Gruß, Thomas
 
beastofchaos hat gesagt.:
Mein Dialog stamtm wie gewohnt von JDialog ab und enthält die beiden Attribute "labelLoad" und "iconLoading", um einen Text und zweitens das GIF-Icon anzuzeigen.
Zum Vergrößern anklicken....
Blos weil man einen Dialog anzeigen will ist es meiner Meinung nach nicht gerechtfertigt von JDialog zu erben. Bau Dir doch eine Hilfsklasse die das ganze behandelt und steuert.
beastofchaos hat gesagt.:
Bloß wie könnte ich sonst eine Aktion nach dem Aufruf von "setVisible(true)" ausführen. Schließlich blockt "setVisible(true)" bei einem Dialog diesen Thread.
Zum Vergrößern anklicken....
Die Aktion bzw. der Thread muss natürlich gestartet werden bevor setVisible(true) auf dem JDialog aufgerufen wird.

Zu Deinem Problem kann ich nicht viel sagen, weder sieht man hier etwas von einem Icon noch wie das Zusammenspiel zwischen Thread starten und Dialog anzeigen ausschaut. Ein KSKB wäre nicht schlecht.
 
main-Methode:
Java: 
public static void main(String[] args)
	{
		// Hauptfenster und Dialog erzeugen
		JFrame frame = new JFrame("Custom tool tip with icon");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(400, 400);
		frame.setLocationRelativeTo(null);
		DLoad.createDialogInstane(frame, "Laden...");

		// Fenster und Dialog nacheinander öffnen. Die Dauer der Aktion wird per "sleep(1000)" simliert
		frame.setVisible(true);
		DLoad.showDialog("Lade Dialog....", new Runnable()
		{
			@Override
			public void run()
			{
				System.out.println("RUN");
				try
				{
					Thread.sleep(1000); // Hier würde die Aktion stehen, welche ausgeführt werden soll.
				} catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		});
		
		// Testweise ein zweites Mal aufrufen
		DLoad.showDialog("Lade Dialog....", new Runnable()
		{
			@Override
			public void run()
			{
				System.out.println("RUN");
				try
				{
					Thread.sleep(1000);
				} catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		});
	}

Die Dialog-Klasse:
Java: 
package dialogs;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Window;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.ImageIcon;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;

import management.CursorAdmin;
import designs.ImageDesign;

/**
 * <strong>DLoad extends JDialog</strong><br>
 * <br>
 * Zeigt eine Lade-Anzeige mit einem Text darunter, welcher beim Öffnen des
 * Dialogs gesetzt wird. <br>
 * <br>
 * Der Dialog ist nur solange offen, wie die Run-Methode ausgeführt wird.
 * 
 * @author Thomas Kellermeier
 */
@SuppressWarnings("serial")
public final class DLoad extends JDialog
{

	// ------Attribute----------------------------------------------------------------------------------------------//

	/**
	 * Zeigt den Text an, welcher beim Öffnen des Dialogs angezeigt wird.
	 * Der Text erscheint direkt unter dem Gif-Icon und ist von <html>-Tags
	 * umschlossen, wodurch Zeilenumbrüche auch simpel eingebaut werden
	 * können, sollte der Text zu lang sein.
	 * 
	 * @see #showDialog(String, Runnable)
	 */
	private JLabel labelLoad;

	/**
	 * Enthält in der Run-Methode die Aktion, die während der Sichtbarkeit
	 * des Dialogs ausgeführt werden soll. Die Methode wird über einen
	 * WindowListener aufgerufen.
	 */
	private Runnable runnableAction;

	/**
	 * Die einzige vorhandene DLoad-Instanz, welche nur intern zum Erzeugen
	 * und Anzeigen verfügbar ist. Die Instanz kann nur neu kosntruiert
	 * werden, wenn sich das neue Objekt von dem alten bezüglich der
	 * Attribute "Owner" und "Title" unterscheidet.
	 */
	private static DLoad instance;

	// ------Konstruktor--------------------------------------------------------------------------------------------//

	/**
	 * Erzeugt den Laden-Dialog, welcher nur mittels einer internen Instanz
	 * aufgerufen werden kann. <br>
	 * <br>
	 * Es wird ein Gif-Icon erzeugt, welches in einem Label zentral gezeigt
	 * wird. Darunter wird der Lade-Text angezeigt, welcher in der
	 * Öffnen-Methode übergeben wird.
	 * 
	 * @param owner
	 *                Das Fenster, über welches der Dialog angezeigt wird.
	 * @param title
	 *                Der Titel des Dialogs.
	 */
	private DLoad(Window owner, String title)
	{
		super(owner, title);
		setModal(true);
		setCursor(CursorAdmin.WAIT_CURSOR);
		setPreferredSize(new Dimension(300, 150));
		addWindowListener(new WindowAdapter()
		{
			@Override
			public void windowOpened(WindowEvent e)
			{
				if (runnableAction != null)
				{
					runnableAction.run();
					setVisible(false);
				}
			}
		});
		Container content = getContentPane();
		content.setLayout(new BorderLayout(10, 10));

		ImageIcon iconLoading = ImageDesign.openImageIcon("/res/images/loading_60.gif", "");
		JLabel labelIcon = new JLabel(iconLoading);
		add(labelIcon, BorderLayout.CENTER);

		labelLoad = new JLabel("");
		labelLoad.setHorizontalAlignment(JLabel.CENTER);
		add(labelLoad, BorderLayout.SOUTH);

		setPreferredSize(new Dimension(300, 150));
		pack();
		setLocationRelativeTo(owner);
	}

	// ------Methoden-----------------------------------------------------------------------------------------------//

	/**
	 * Erzeugt die Dialog-Instanz, welche zum Öffnen des Laden-Dialogs
	 * benuzt wird. Wenn die Methode vorher bereits mit den selben
	 * Parametern aufgerufen wurde, bleibt die Instanz unangetastet.
	 * 
	 * @see #showDialog(String, Runnable)
	 */
	public static void createDialogInstane(Window owner, String title)
	{
		if (instance == null || !instance.getOwner().equals(owner)
				|| !instance.getTitle().equals(title))
		{
			instance = new DLoad(owner, title);
		}
	}

	/**
	 * Öffnet den Dialog und führt die jeweilig Aktion aus. Nach dem
	 * Abschließen der Aktion wird der Dialog wieder geschlossen. <br>
	 * <br>
	 * Der Text, der die jeweilig Aktion beschreibt wird automatisch mit
	 * HTML-Tags umschlossen und erlaubt so auch <em>manuelle</em>
	 * Zeilenumbrüche, wenn der Text für das Anzeige-Label zu lang sein
	 * sollte. <br>
	 * <br>
	 * Die Aktion, welche in der Run-Methode des zweiten Parameters
	 * aufgeführt werden sollte, wird aufgerufen, wenn das Fenster
	 * erfolgreich geöffnet wurde. <br>
	 * <br>
	 * <strong>Warnung: Die dafür benutzte Dialog-Instanz muss vorher
	 * erzeugt werden.</strong>
	 * 
	 * @see #createDialogInstane(JFrame, String)
	 * @throws NullPointerException
	 *                 Wenn noch keine Dialog-Instanz generiert wurde.
	 */
	public static void showDialog(String loadMessage, Runnable runnableAction)
	{
		if (instance == null)
		{
			throw new NullPointerException(
					"Dialog instance has to be created before trying open it!");
		}
		else
		{
			instance.runnableAction = runnableAction;
			instance.labelLoad.setText("<html>" + loadMessage + "<br>&nbsp;</html>");

			instance.setVisible(true);
		}
	}
}


Im Anhang nochmal der Dialog und meine Laden-GIF. Die GIF-Datei muss natürlich hinzugefügt werden und der Pfad angepasst werden, ja nach dem wo du sie hinlegst

Gruß, Thomas
 

Anhänge

  • DLoad.java
    DLoad.java
    4,9 KB · Aufrufe: 2
  • loading_60.gif
    loading_60.gif
    7,6 KB · Aufrufe: 55
1. nicht die run() eines Threads oder Runnables selbst aufrufen. Runnable Objekte werden immer einem Thread übergeben und ein neuer Thread wird immmer mit start() gestartet. Der direkter Aufruf von run() führt den Code einfach nur im aktuellen Thread aus.
2. wieso der WindowListener im Dialog? Du hast doch bereits eine Methode showDialog(...) hier einfach bevor Du setVisible auf den Dialog aufrufs ein Thread Objekt erzeugen (das Runnable im Konstruktor übergeben) und daran start() aufrufen.
 
Die Problemstellung die dann noch offen bleibt, ist das Schließen des Dialogs nach Abarbeitung des Threads. Eventuell wäre es dann besser nicht ein Runnable zu übergeben sondern einen eigene Klasse zu definieren, das Runnable im Kontext des Dialogs zu erstellen damit hier der Aufruf des "Jobs" und das Schließen des Dialogs durchgeführt werden kann.
 
Das Problem ist jetzt ganz gelöst. Der übersprüngliche Code zum Öffnen:
Java: 
        instance.runnableAction = runnableAction;
        instance.labelLoad.setText("<html>" + loadMessage + "<br>&nbsp;</html>");
        addWindowListener(new WindowAdapter()
        {
            @Override
            public void windowOpened(WindowEvent e)
            {
                if (runnableAction != null)
                {
                    runnableAction.run();
                    setVisible(false);
                }
            }
        });
        instance.setVisible(true);

Die Lösung mit einem Thread:
Java: 
        instance.runnableAction = runnableAction;
        instance.labelLoad.setText("<html>" + loadMessage + "<br>&nbsp;</html>");

        Thread threadRun = new Thread(runnableAction)
        {
                @Override
                public void run()
                {
                        instance.runnableAction.run();
                        instance.setVisible(false);
                }
        };
        threadRun.start();
        instance.setVisible(true);

Lösung war also tatsächlich ein neues Thread-Objekt. Wusste das bis her nicht - dachte Runnable ist die Klasse um einfach Methoden als Parameter zu übergeben 🙂)) Danke hierfür.

Gruß, Thomas
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

VaterFrame des modal-Dialogs beklickbar
Antworten: 12
Rahmengröße des Frames/Dialogs
Antworten: 3
Position des Print Dialogs vorgeben
Antworten: 3
Von Instanz des Dialogs auf das Frame zugreifen
Antworten: 8
Eine Aktion nach Keyinput nachhalten lassen
Antworten: 6

Zurück
Oben