Windows in LinkedList registrieren

[fishychips]

Vielen Dank für die Aufnahme! Ich habe ein Problem beim Hinzufügen Fenstern zu einer LinkedList aus einer anderen Klasse.

Es sollen bestimmte Fenster, die über mehrere Klassen erzeugt werden, zu einer LinkedList hinzugefügt werden. Alle Klassen greifen auf die Klasse EventHandler zu, der das Öffnen und Schließen dieser Fenster regelt. Deshalb habe ich dies auch als Event genutzt (funktioniert auch). Die LinkedList befindet sich jedoch in der Klasse Main und über die dort definierten Methoden können Daten hinzugefügt oder entfernt werden. Der EventHandler greift auf die Main-Klasse zu, indem ein entsprechender Konstruktor definiert wird.

Das Problem ist jetzt, dass meine LinkedList zwar die neuen Fenster brav einliest, aber die alten Daten "vergisst" sobald die Methode EventHandler wieder aufgerufen wird.

Code der Klasse "Main":

import java.awt.Window;
import java.util.LinkedList;

import javax.swing.JFrame;

public class Main {

    private LinkedList WindowList = new LinkedList();

    public void addFrame(Window w) {
        WindowList.add(w);
        System.out.println(WindowList.size());
    }

    public void removeFrame(Window w) {
        WindowList.remove(w);
        System.out.println(WindowList.size());
    }

    public LinkedList getWindowList() {
        return WindowList;
    }

}

Code der Klasse "EventHandler":

import java.awt.Window;
import java.awt.event.WindowEvent;
import java.util.ListIterator;

//Wird von verschiedenen Klassen als WindowListener implementiert
public class EvenHandler {

    Main app = new Main();

    public void windowOpened(WindowEvent e) {
        Window w = e.getWindow();
        app.addFrame(w);
    }

    public void windowClosing(WindowEvent e) {

        Window w = e.getWindow();
        app.removeFrame(w);
        w.dispose();
    }
}

 

[kneitzel]

Also an dem Code kann ich erst einmal nichts erkennen. Hast Du evtl. mehrere Instanzen von EventHandler? Kannst Du den übrigen Code evtl. auch noch zeigen?

Und noch ein Hinweis zu Deiner LinkedList:
a) Du solltest hier Generics verwenden, also eine List<Window> / LinkedList<Window>.
b) Du solltest LinkedList nur bei der Erzeugung der Liste nutzen und ansonsten auf das Interface List zurück greifen. Dann kannst Du bei der genauen Implementierung später einfacher wechseln. Solltest Du also später eine ArrayList nutzen wollen, ist nur eine Stelle zu ändern.

 

[Robat]

Ich würde eher sagen, dass er woanders noch eine Instanz von Main besitzt (zum "einlesen") - der EventHandler aber eine eigene Main Instanz nutzt

 

[fishychips]

ok, schon mal vielen Dank! die Änderungen an der LinkedList werde ich entsprechend vornehmen.

Grundsätzlich geht es im ganzen Progamm darum, verschiedene Dokumente über eine Treemap auszuwählen und per Doppelklick in einem neuen Frame anzuzeigen. Für verschiedene Arten von Dokumenten existieren dabei verschiedene Klassen zur Ausgabe, z. B. Tonausgabe oder Bildausgabe mit jeweils erbender Ausgabeklasse. Diese Klassen rufen dann auch den EventHandler auf. Hier mal ein Beispiel für die Ausgabe von Bilddokumenten:

Klasse BildDokument (erbt nur einige grundsätzliche Eigenschaften, wie Beschreibung, Pfad und Name sowie Methode "dokumentAusgeben" aus Klasse "Dokument"):

public class BildDokument extends Dokument {

    public BildDokument(String name, String filePath, String beschreibung) {
        /* Aufruf des Konstruktors der Basisklasse */
        super(name, filePath, beschreibung);
    }

    @Override
    public void dokumentAusgeben() {
        new BildDokumentAusgabe(this);
    }
}

Klasse BildDokumentAusgeben

import java.awt.*;
import java.awt.image.FilteredImageSource;
import java.awt.image.ImageFilter;
import java.awt.image.ReplicateScaleFilter;

import javax.swing.*;

/**
* JFrame-Klasse zur Ausgabe von Bilddokumenten
*/
public class BildDokumentAusgabe extends JFrame implements DokumentAusgabeIF {

    private Image bild;
    private String bildName;
    private int topInset;
    public String WindowListElement = "leer";
    // Main app = new Main();

    /*
     * public String WindowListElement() { System.out.println(this.getName());
     * return this.getName();
     *
     * } /*
     *
     * /* public static void main(String[] args){ BildDokument dok = new
     * BildDokument("ein Bild", "C:\\JAV08\\Bilder\\Kranich.jpg", "");
     * dok.dokumentAusgeben(); }
     */

    public BildDokumentAusgabe(BildDokument bildDokument) {
        bildName = bildDokument.getName();

        this.setTitle("Bilddokumentausgabe");
        this.addWindowListener(new DokumentAusgabeEventHandler());
        this.setResizable(false);
        topInset = Main.getTopInset();
        if (this.bildLaden(bildDokument.getFilePath())) {
            this.setSize(this.limitSize(bild.getWidth(this), bild.getHeight(this)));
        } else {
            // feste Größe für die Ausgabe einer
            // Fehlermeldung:
            this.setSize(400, 100);
        }

        // app.WindowList.add(this.getName());
        // System.out.println(app.WindowList.size());
        // WindowListElement();
        String WindowListElement = this.getName();
        // System.out.println(WindowListElement);
        // app.addFrame(WindowListElement);

        this.setContentPane(new JPanel() {
            @Override
            public void paintComponent(Graphics g) {
                if (bild.getHeight(this) > -1)
                    g.drawImage(bild, 0, 0, this);
            }
        });
        this.setVisible(true);
    }

    /**
     * Prüft, ob die Größe des geladenen Bildes die Vorgaben der Konstanten MAX_SIZE
     * überschreitet. Wenn nein, wird ein Dimension-Objekt mit den Größen des
     * geladenen Bildes zurückgegeben, wenn ja, so wird das Bild nach Maßgabe von
     * MAX_SIZE herunterskaliert.
     *
     * @param width
     *            Breite des geladenen Bildes
     * @param height
     *            Höhe des geladenen Bildes
     * @return java.awt.Dimension-Objekt zur Definition der Größe des darstellenden
     *         Frames
     */
    private Dimension limitSize(int width, int height) {

        if (width > Konstanten.MAX_SIZE_BILDAUSGABE.width || height > Konstanten.MAX_SIZE_BILDAUSGABE.height) {
            int scaledWidth = (width > height) ? Konstanten.MAX_SIZE_BILDAUSGABE.width
                    : Konstanten.MAX_SIZE_BILDAUSGABE.height * width / height;
            int scaledHeight = (width > height) ? Konstanten.MAX_SIZE_BILDAUSGABE.width * height / width
                    : Konstanten.MAX_SIZE_BILDAUSGABE.height;
            ImageFilter scaleFilter = new ReplicateScaleFilter(scaledWidth, scaledHeight);
            this.bild = createImage(new FilteredImageSource(bild.getSource(), scaleFilter));
            return new Dimension(scaledWidth, scaledHeight + this.topInset);
        } else
            return new Dimension(width, height + this.topInset);
    }

    /**
     * Lädt das spezifizierte Bild mithilfe eines java.awt.MediaTracker-Objekts.
     *
     * @param filePath
     *            Pfad auf die Bilddatei
     * @return true, wenn erfolgreich geladen, anderenfalls false
     */

    private boolean bildLaden(String filePath) {
        System.out.println(filePath);
        bild = Toolkit.getDefaultToolkit().getImage(filePath);
        MediaTracker tracker = new MediaTracker(this);
        tracker.addImage(bild, 0);
        try {
            tracker.waitForID(0);
            // Test auf korrektes Laden:
            if (bild.getHeight(this) > -1)
                return true;
            else
                return false;
        } catch (InterruptedException ie) {
            System.out.println(ie.toString() + "\nbeim Laden des Bildes \"" + filePath);
            return false;
        }
    }

    @Override
    public void ausgabeBeenden() {
        // TODO Auto-generated method stub
       
    }

Hier noch einmal die Initialisierung in der Klasse "Main" (ohne Methoden für EventHandling im TreeMap und Menüerstellung):

public class Main extends JFrame implements LinkedListIF {

    private static int topInset;

    public static int getTopInset() {
        return topInset;
    }

    // GUI-Objekte
    private JTree jTree;
    // Model-Objekte
    private DefaultTreeModel treeModel;
    private Katalog topLevelKatalog;
    private IOVerwaltung ioVerwaltung;
    // Menü
    private Action actAddKat, actAddDoc, actCopy, actCut, actPaste, actDelete, actRename;
    // Statusleiste/Textfeld Beschreibung
    private JTextField jtfStatus;
    private JTextArea jtaBeschreibung;
    // Knoten-Cache
    private Knoten[] knotenCache = null;
    // PopUp-Menü
    private JPopupMenu popupJTreeDokumentSelektion;
    private JPopupMenu popupJTreeKatalogSelektion;
    private JPopupMenu popupJTreeMehrfachSelektion;
    public LinkedList<Window> WindowList = new LinkedList();

    public Main() {
        super("Medienverwaltung");

    }

    public static void main(String[] args) {
        Main app = new Main();
        String filePath = Konstanten.DEFAULT_PATH;
        app.initializeApplication(filePath);
    }

    public void addFrame(Window w) {
        WindowList.add(w);
        System.out.println(WindowList.size());
    }

   
    public void removeFrame(Window w) {
        WindowList.remove(w);
        System.out.println(WindowList.size());
    }
   
    public LinkedList getWindowList() {
        return WindowList;
    }

    // TreeMap initialisieren
    private void initializeApplication(String filePath) {
        ioVerwaltung = new IOVerwaltung();
        this.setSize(Konstanten.GUI_DIMENSION);
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent we) {
                System.exit(0);
            }
        });

        topLevelKatalog = new Katalog("TopLevelKatalog");
        treeModel = new DefaultTreeModel(topLevelKatalog);
        // leere Ordner nicht mit Dokumenten-Symbol darstellen
        treeModel.setAsksAllowsChildren(true);
        if (filePath != null) {
            ioVerwaltung.baumEinlesen(topLevelKatalog, filePath);
        }
        jTree = new JTree(treeModel);
        jTree.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
        jTree.setEditable(true);
        JScrollPane jScrollPane = new JScrollPane(jTree);
        this.add(jScrollPane, BorderLayout.CENTER);
        createMenus();
        addAusgabebereich();
        this.addEventHandlers();
        this.createPopupMenus();
        this.setVisible(true);
        topInset = this.getInsets().top;

    }
}

Es kann gut sein, dass mehrere Instanzen erzeugt werden. Das ist glaube ich auch mein Problem. Ich weiß bloß nicht, wie ich es hier umgehen kann