Guten Tag
Habe ein programm geschrieben für Medienverwaltung.
Soweit funktioniert alles. Jetzt möchte ich das die Fenster z.B. MP3, Ton und Bild nebem meinem programm aufgehen und wen ich ein weiteres öffne dann soll es ca 25x25 pixel weite weg erscheien als das davor.
Jemmand ein vorschlag wie ich das machen kann?
Bei bedarf kann ich alle klasse hir einfügen sind 15 stk. Hoffe es geht so könnt gern eigene Variablen benutzen.
Hmjawas… mit frame.setBounds(x,y,w,h) kann man sein Fenster hinsetzen, wo man will. Wenn schon eins offen ist (‘mainFrame’) und man seinen Frame 25 Pixel daneben packen will, einfach
int x = mainFrame.getX()+mainFrame.getWidth()+25;
int y = mainFrame.getY();
frame.setBounds(x,y,w,h);
[Window#setLocation()](http://docs.oracle.com/javase/7/docs/api/java/awt/Window.html#setLocation(int, int))
oder wahrscheinlich noch besser:
Window#setLocationRelativeByPlatform()
…macht das schon automatisch.
Ansonsten kann man sich über das Thema und viele andere im Wiki belesen. Byte-Welt-Wiki - Fenster mittig auf dem Bildschirm zentrieren
Ok Danke für den Tipp ich versuche es mal.
Habe noch etwas und zwar möchte ich die besagten fenster per Button gleichzeitig schließen aber nicht das haupt Fenster
Ich dachte da an eine liste und diese Methode
public void windowOpened(WindowEvent event)
nur wie mache ich das damit?
Wenn der Button geklickt wird, kann man alle Fenster disposen:
for (TheWindow w : theWindows)
{
w.setVisible(false);
w.dispose();
}
(das könnte z.B. in der actionPerformed des Buttons stehen…)
Hir ist mein Code die Methode wäre private void defineActionBeenden() nur mach ich wohlt etwas falsch bekommen nur ein exception ich vermute ich hatte falsche variable benutzt. Vieleicht hilft das etwas besser zu verstehen. Bei bedarf kann ich auch noch andere Klassen hinzufügen. Zeile ca 274
Aus platzgründen habe ich die codes von ein paar buttens entfernt.
Braucht man den ein referenz auf die besagten Klassen der Fenster oder neue Variable?
public class Main extends JFrame {
private static int topInset;
private Action actAddKat, actAddDoc, actCopy, actCut, actPaste, actDelete,
actRename, actEnd;
private JTextField jtfStatus;
private JTextArea jtaBeschreibung;
private Knoten[] knotenCache = null;
/* ***** Popup-Menüs ***** */
private JPopupMenu popupJTreeDokumentSelektion;
private JPopupMenu popupJTreeMehrfachSelektion;
private JPopupMenu popupJTreeKatalogSelektion;
private void addEventHandlers() {
jTree.addMouseListener(new JTreeMouseListener());
// hier können weitere Listener angemeldet werden
jTree.addTreeSelectionListener(new JTreeSelectionListener());
}
private class JTreeMouseListener extends MouseAdapter {
private TreePath clickedNodePath;
private int selectedRow;
@Override
public void mousePressed(MouseEvent me) {
// Row-Auswertung
int selectedRow = jTree.getRowForLocation(me.getX(), me.getY());
if (me.getComponent() == jTree && selectedRow != -1) {
// Path-Auswertung
clickedNodePath = jTree
.getPathForLocation(me.getX(), me.getY());
Knoten knoten = (Knoten) clickedNodePath.getLastPathComponent();
// 2-fach Klick feststellen,
// Kataloge ausschließen:
if (me.getClickCount() == 2 && !knoten.getAllowsChildren())
((Dokument) knoten).dokumentAusgeben();
this.checkMouseRight(me);
// weiterleiten
} else {
// Selektion bei Klick daneben aufheben:
jTree.removeSelectionPaths(jTree.getSelectionPaths());
// und auch die Instanzvariable löschen
clickedNodePath = null;
}
}
// (fett-Stellungen dienen der Übersicht):
@Override
public void mouseReleased(MouseEvent me) {
if (selectedRow != -1)
this.checkMouseRight(me); // weiterleiten
}
private void checkMouseRight(MouseEvent me) {
if (me.isPopupTrigger() // rechte Maustaste
&& selectedRow != -1) {
TreePath[] selectedPaths = jTree.getSelectionPaths();
if (selectedPaths != null) {
if (!clickedNodePathInSelectedTreePaths(clickedNodePath,
selectedPaths) || selectedPaths.length == 1) { // s.
// Hinweis
// clickedNodePath nicht in selectedPaths:
jTree.setSelectionPath(clickedNodePath);
//popupJTreeDokumentSelektion.show(me.getComponent(),me.getX(), me.getY());
this.katalogOrDokument(me);
} else {
// clickedNodePath in selectedPaths:
//popupJTreeMehrfachSelektion.show(me.getComponent(),me.getX(), me.getY());
this.katalogOrDokument(me);
}
} else {
// keine selectedPaths
jTree.setSelectionPath(clickedNodePath);
popupJTreeDokumentSelektion.show(me.getComponent(),
me.getX(), me.getY());
}
}
}
private void katalogOrDokument(MouseEvent me){
if
((Knoten)clickedNodePath.getLastPathComponent()
instanceof Katalog)popupJTreeKatalogSelektion.show(me.getComponent(), me.getX(), me.getY());
else
popupJTreeDokumentSelektion.show(me.getComponent(), me.getX(), me.getY());
}
private boolean clickedNodePathInSelectedTreePaths(
TreePath clickedNodePath, TreePath[] selectedPaths) {
for (TreePath path : selectedPaths) {
if (path.equals(clickedNodePath))
return true;
}
return false;
}
}
// neue innere Klasse:
private class JTreeSelectionListener implements TreeSelectionListener {
public void valueChanged(TreeSelectionEvent tse) {
DefaultMutableTreeNode lastNode = (DefaultMutableTreeNode) jTree
.getLastSelectedPathComponent();
if (lastNode == null)
return;
if (lastNode instanceof Dokument) {
jtaBeschreibung
.setText(((Dokument) lastNode).getBeschreibung());
}
}
}
public static int getTopInset() {
return topInset;
}
// GUI-Objekte
private JTree jTree;
// Model-Objekte
private DefaultTreeModel treeModel;
private Katalog topLevelKatalog;
private IOVerwaltung ioVerwaltung;
public Main() {
super("Medienverwaltung");
createMenus();
addAusgabebereich();
popupJTreeKatalogSelektion = new JPopupMenu("Operationen auf einem Katalog");
popupJTreeKatalogSelektion.add(actCopy);
popupJTreeKatalogSelektion.add(actCut);
popupJTreeKatalogSelektion.add(actPaste);
popupJTreeKatalogSelektion.add(actDelete);
popupJTreeKatalogSelektion.add(actRename);
}
/**
* Erst mal nur für Tests: feste Verdrahtung auf ein einzulesendes
* Verzeichnis.
*
* @param args
* keine Verarbeitung von Aufrufparametern
*/
public static void main(String[] args) {
Main app = new Main();
String filePath = Konstanten.DEFAULT_PATH;
app.initializeApplication(filePath);
app.durchsucheKatalog();
}
/**
* Initialisiert die Anwendung – im weiteren Ausbau: GUI, EventHandler,
* Menüs, PopupMenüs usw.
*
* @param filePath
* Startpfad auf das Dateisystem, kann auch null sein.
*/
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);
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);
this.setVisible(true);
topInset = this.getInsets().top;
this.addEventHandlers();
this.createPopupMenus();
}
private void durchsucheKatalog() {
Katalog katalog = topLevelKatalog;
if (katalog != null) {
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
String inputString = null;
try {
System.out.println("Bitte Dateinamen eingeben "
+ "(Abbruch mit \"end\")>");
while (((inputString = reader.readLine()) != null)
&& (!inputString.equals("end"))) {
Dokument doc = katalog.sucheDokument(inputString);
if (doc != null) {
doc.dokumentAusgeben();
System.out.println("Ausgabe von \"" + inputString
+ "\"");
} else
System.out
.println("Kein Dokument mit " + "dem Namen \""
+ inputString + "\" gefunden.");
}
} catch (IOException ioe) {
System.out.println("Fehler beim Einlesen - " + ioe.toString());
}
System.exit(0);
}
}
private void createMenus() {
JMenuBar menuBar = new JMenuBar();
/* ********** Menü: Kataloge verwalten ********** */
JMenu menuVerwalten = new JMenu("Kataloge verwalten");
JMenuItem jmiEinlesen = getJmiKatalogEinlesen();
menuVerwalten.add(jmiEinlesen);
JMenuItem jmiLaden = getJmiKatalogLaden();
menuVerwalten.add(jmiLaden);
menuVerwalten.addSeparator();
JMenuItem jmiSaveAs = getJmiSpeichernUnter();
menuVerwalten.add(jmiSaveAs);
JMenuItem jmiSave = getJmiSpeichern();
menuVerwalten.add(jmiSave);
menuVerwalten.addSeparator();
defineActionKatalogErgänzen();
menuVerwalten.add(actAddKat);
defineActionDokumentErgänzen();
menuVerwalten.add(actAddDoc);
JMenuItem jmiSuchen = getJmiDokumentSuchen();
menuVerwalten.add(jmiSuchen);
/* ********** Menü: Knoten bearbeiten ********** */
JMenu menuBearbeiten = new JMenu("Knoten bearbeiten");
defineActionKopieren();
menuBearbeiten.add(actCopy);
defineActionAusschneiden();
menuBearbeiten.add(actCut);
defineActionEinfügen();
actPaste.setEnabled(false);
menuBearbeiten.add(actPaste);
defineActionLöschen();
menuBearbeiten.add(actDelete);
defineActionKnotennameÄndern();
menuBearbeiten.add(actRename);
/* ********** Menü: Operationen ********** */
JMenu menuOperationen = new JMenu("Operationen");
defineActionBeenden();
menuOperationen.add(actEnd);
/* ********** Zusammenbau ********** */
menuBar.add(menuVerwalten);
menuBar.add(menuBearbeiten);
menuBar.add(menuOperationen);
this.setJMenuBar(menuBar);
}
private void defineActionBeenden() {
actEnd = new AbstractAction("Alle Fenster Schließen") {
public void actionPerformed(ActionEvent e) {
System.out.println("Alle Fenster geschlossen");
}
};
}
// getJmiXxx-Methoden
private JMenuItem getJmiDokumentSuchen() {
JMenuItem jmiSuchen = new JMenuItem("Dokument suchen...");
jmiSuchen.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println("\"Dokument suchen ...\" gewählt");
}
});
return jmiSuchen;
}
private JMenuItem getJmiSpeichern() {
JMenuItem jmiSave = new JMenuItem("Speichern");
jmiSave.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println("\"Speichern ...\" gewählt");
}
});
return jmiSave;
}
private JMenuItem getJmiSpeichernUnter() {
JMenuItem jmiSaveAs = new JMenuItem("Speichern unter...");
jmiSaveAs.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JFileChooser fileChooser = new JFileChooser(
Konstanten.DEFAULT_PATH);
fileChooser.setDialogTitle("Datei zum Serialisieren festlegen");
int returnValue = fileChooser.showSaveDialog(Main.this);
if (returnValue == JFileChooser.APPROVE_OPTION) {
File file = fileChooser.getSelectedFile();
ioVerwaltung.serialize((Knoten) treeModel.getRoot(), file);
jtfStatus.setText("Katalog unter \"" + file.getName()
+ "\" gespeichert");
} else
jtfStatus.setText("Speichern abgebrochen");
}
});
return jmiSaveAs;
}
private JMenuItem getJmiKatalogLaden() {
JMenuItem jmiLaden = new JMenuItem("Katalog laden...");
jmiLaden.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JFileChooser fileChooser = new JFileChooser(".");
fileChooser.setDialogTitle("Serialisierungsdatei auswählen");
int returnValue = fileChooser.showOpenDialog(Main.this);
if (returnValue == JFileChooser.APPROVE_OPTION) {
File file = fileChooser.getSelectedFile();
Knoten temp = ioVerwaltung.deserialize(file);
if (temp == null)
jtfStatus.setText("Der Katalog \"" + returnValue
+ "\" konnte nicht geladen werden.");
else {
treeModel.setRoot(temp);
jtfStatus.setText("Katalog aus \"" + file.getName()
+ "\" geladen.");
}
} else
jtfStatus.setText("\"Katalog laden\" abgebrochen");
}
});
return jmiLaden;
}
private JMenuItem getJmiKatalogEinlesen() {
JMenuItem jmiEinlesen = new JMenuItem("Katalog einlesen...");
jmiEinlesen.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
knotenCache = getSelectedNodes();
if (knotenCache != null && knotenCache.length == 1
&& knotenCache[0] instanceof Katalog) {
JFileChooser fileChooser = new JFileChooser(".");
fileChooser.setDialogTitle("Ordner zum Einlesen in \""
+ knotenCache[0].getName() + "\" auswählen");
fileChooser
.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int returnValue = fileChooser.showOpenDialog(Main.this);
if (returnValue == JFileChooser.APPROVE_OPTION) {
String returnString = fileChooser.getSelectedFile()
.getAbsolutePath();
// casting ist oben geprüft!
ioVerwaltung.baumEinlesen((Katalog) knotenCache[0],
returnString);
// ganz wichtig: das TreeModel informieren
treeModel.reload(knotenCache[0]);
// und gleich den Zielordner expandieren
jTree.expandPath(new TreePath(knotenCache[0].getPath()));
jtfStatus.setText("Dateisystem eingelesen");
}
} else
jtfStatus.setText("Vor dem Einlesen muss ein "
+ " Katalog ausgewählt werden!");
}
});
return jmiEinlesen;
}
// defineActionXxx-Methoden
private void defineActionKnotennameÄndern() {
actRename = new AbstractAction("Knotenname ändern") {
public void actionPerformed(ActionEvent e) {
knotenCache = getSelectedNodes();
// nur e i n Knoten darf selektiert sein:
if (knotenCache != null && knotenCache.length == 1) {
String nodeType = null;
if (knotenCache[0] instanceof Katalog)
nodeType = "Katalog \"";
else
nodeType = "Dokument \"";
String returnString = JOptionPane.showInputDialog(
Main.this, nodeType + knotenCache[0].getName()
+ "\" umbenennen:", "Neuer Knotenname",
JOptionPane.PLAIN_MESSAGE);
// hier die returnString-Verarbeitung ergänzen
if (returnString == null)
jtfStatus.setText("Dialog abgebrochen");
else if (returnString.equals(""))
jtfStatus.setText("OK ohne Eingabe");
else if (returnString.length() > 0) {
knotenCache[0].setName(returnString);
}
} else
jtfStatus.setText("Bitte zunächst einen Knoten "
+ "auswählen.");
}
};
}
private void defineActionLöschen() {
actDelete = new AbstractAction("Löschen") {
public void actionPerformed(ActionEvent e) {
knotenCache = getSelectedNodes().clone();
knotenCache = null;
// zunächst selektierte Knoten ermitteln:
knotenCache = getSelectedNodes();
String message = "";
if (knotenCache.length == 1)
message = "Soll der ausgewählte Knoten "
+ "wirklich gelöscht werden?";
else
message = "Sollen die ausgewählten Knoten wirklich "
+ "gelöscht werden?";
int returnValue = JOptionPane.showConfirmDialog(jTree, message,
"Löschen bestätigen", JOptionPane.OK_CANCEL_OPTION);
// Löschen abhängig vom Rückgabewert:
if (returnValue == JOptionPane.OK_OPTION) {
// ... vorhandene Implementierung
Knoten parent = (Knoten) knotenCache[0].getParent();
if (parent != null)
System.out.println("parent von "
+ knotenCache[0].getName() + " ist: "
+ parent.getName());
else
System.out.println("parent von "
+ knotenCache[0].getName() + " ist null");
}
actPaste.setEnabled(false);
}
};
}
private void defineActionEinfügen() {
actPaste = new AbstractAction("Einfügen") {
public void actionPerformed(ActionEvent e) {
Knoten[] temp = getSelectedNodes(); // Zielordner
if (temp != null) {
if (temp.length == 1 && temp[0] instanceof Katalog) {
for (Knoten cacheNode : knotenCache)
// sortiert einfügen:
treeModel.insertNodeInto(cacheNode, temp[0],
((Katalog) temp[0])
.getInsertIndexFor(cacheNode));
// und gleich den Zielordner expandieren:
jTree.expandPath(new TreePath(temp[0].getPath()));
jtfStatus.setText("Knoten eingefügt");
} else
jtfStatus.setText("Als Ziel ist nur e i n Knoten "
+ "vom Typ \"Katalog\" zulässig!");
} else
jtfStatus.setText("Kein Katalog zum einfügen "
+ "ausgewählt");
}
};
}
private void defineActionKopieren() {
actCopy = new AbstractAction("Kopieren") {
public void actionPerformed(ActionEvent e) {
Knoten[] knotenArray = getSelectedNodes();
// NullPointerException bei fehlender
// Auswahl vermeiden:
if (knotenArray != null && knotenArray.length > 0) {
knotenCache = cloneKnotenArray(knotenArray);
actPaste.setEnabled(true);
jtfStatus.setText("Knoten kopiert");
} else {
jtfStatus.setText("Bitte zunächst eine Auswahl treffen");
}
}
};
}
private void defineActionKatalogErgänzen() {
actAddKat = new AbstractAction("Katalog ergänzen...") {
public void actionPerformed(ActionEvent e) {
knotenCache = getSelectedNodes();
if (knotenCache != null && knotenCache.length == 1
&& knotenCache[0] instanceof Katalog) {
String returnString = JOptionPane.showInputDialog(
Main.this,
"Katalog zu \"" + knotenCache[0].getName()
+ "\" ergänzen:", "Neuer Katalogname",
JOptionPane.PLAIN_MESSAGE);
if (returnString == null)
jtfStatus
.setText("Dialog abgebrochen: " + returnString);
else if (returnString.equals(""))
jtfStatus.setText("keine Eingabe");
else if (returnString.length() > 0) {
Katalog katalog = new Katalog(returnString);
// auch hier sortiert einfügen:
treeModel.insertNodeInto(katalog, knotenCache[0],
((Katalog) knotenCache[0])
.getInsertIndexFor(katalog));
jtfStatus.setText("Katalog \"" + returnString
+ "\" ergänzt");
}
} else {
jtfStatus.setText("Ein Katalog kann nur zu "
+ "e i n e m ausgewählten Katalog "
+ "ergänzt werden.");
}
}
};
}
private void addAusgabebereich() {
jtaBeschreibung = new JTextArea("Dies ist ein Probetext ");
jtaBeschreibung.setBorder(BorderFactory
.createBevelBorder(BevelBorder.LOWERED));
jtaBeschreibung.setLineWrap(true);
JScrollPane jspAusgabe = new JScrollPane(jtaBeschreibung);
jtfStatus = new JTextField();
jtfStatus.setForeground(Color.WHITE);
jtfStatus.setBackground(Color.DARK_GRAY);
jtfStatus.setEditable(false);
JPanel jpanelAusgabe = new JPanel(new BorderLayout());
jpanelAusgabe.setPreferredSize(new Dimension(this.getSize().width, 85));
jpanelAusgabe.add(jspAusgabe, BorderLayout.CENTER);
jpanelAusgabe.add(jtfStatus, BorderLayout.SOUTH);
this.getContentPane().add(jpanelAusgabe, BorderLayout.SOUTH);
}
/**
* Ermittelt die selektierten Knoten im JTree.
*
* @return ein Knoten-Array, ermittelt aus einem TreePath-Array
*/
private Knoten[] getSelectedNodes() {
TreePath[] treePaths = jTree.getSelectionPaths();
if (treePaths == null) {
jtfStatus.setText("Zunächst einen Knoten auswählen!");
return null;
}
int treePathsLength = treePaths.length;
Knoten[] returnArray = new Knoten[treePathsLength];
for (int i = 0; i < treePathsLength; i++)
returnArray** = (Knoten) treePaths**.getLastPathComponent();
return returnArray;
}
private Knoten[] cloneKnotenArray(DefaultMutableTreeNode[] nodeArray) {
Knoten[] returnArray = new Knoten[nodeArray.length];
for (int i = 0; i < nodeArray.length; i++)
returnArray** = (Knoten) nodeArray**.clone();
return returnArray;
}
/**
* Erstellt alle Popup-Menüs, die von der Anwendung
* unterstützt werden.
*/
private void createPopupMenus() {
popupJTreeDokumentSelektion = new JPopupMenu(
"Operationen auf einem Dokument");
popupJTreeDokumentSelektion.add(actCopy);
popupJTreeDokumentSelektion.add(actCut);
popupJTreeDokumentSelektion.add(actDelete);
popupJTreeDokumentSelektion.add(actRename);
// Ohne Einfügen bei Operation auf Dokument!
popupJTreeMehrfachSelektion = new JPopupMenu(
"Operationen auf mehreren Knoten");
popupJTreeMehrfachSelektion.add(actCopy);
popupJTreeMehrfachSelektion.add(actCut);
popupJTreeMehrfachSelektion.add(actDelete);
// ohne Umbenennen und Einfügen bei Mehrfachselektion!
}
}
wollte bearbeiten nicht zitieren drücken 
So ganz habe ich die Frage nicht verstanden. Natürlich braucht man Referenzen auf die Fenster, die man schließen will (zumindest ist das im Idealfall so). Im geposteten Pseudocode lägen die Fenster eben in einer “List theWindows”. Und … welche Exception kommt wo?
public BildDokumentAusgabe Bild;
public MP3DokumentAusgabe MP3;
public TonDokumentAusgabe Ton;
.
.
.
private void defineActionBeenden() {
actEnd = new AbstractAction("Alle Fenster Schließen") {
public void actionPerformed(ActionEvent e) {
ArrayList<JFrame> a = new ArrayList<JFrame>();
a.add(Bild);
a.add(MP3);
a.add(Ton);
//Iterator besorgen und Reihe ausgeben
for(Iterator<JFrame> it = a.iterator() ; it.hasNext() ; ){
dispose();
}
System.out.println("Alle Fenster geschlossen");
}
};
}```
So würde ich mein haupt Fenster schließen aber nicht die anderen oder hab ich da flashce referenzen?Wenn du die Fenster schon so als Referenzen hast, könntest du in der ActionPerformed auch einfach
Bild.dispose();
MP3.dispose();
Ton.dispose();
schreiben. Man muss sie nicht extra in eine Liste packen. (Es war nur bisher nicht klar, WIE du diese zu schließenden Fenster vorliegen hast…)
Das geht so nicht. Mein Lehrer hatt follgendes geschrieben.
Es ist sinnvoll, alle geöffneten Fenster in einer Liste zu verwalten. Dies erfor-
dert – unabhängig von der Funktion „Alle Ausgabefenster schließen“
zunächst das An- und Abmelden eines Ausgabefensters bei der Liste, wenn ein
solches Fenster geöffnet bzw. geschlossen wird. Das Schließen aller Fenster
können Sie erreichen, wenn Sie über die Liste iterieren. Denken Sie in diesem
Zusammenhang auch daran, jedes geschlossene Fenster aus der Liste zu ent-
fernen. Beachten Sie (Studium der Iterator-Dokumentation), dass das Iterator-
Objekt inkonsistent wird, wenn Sie Fensterunmittelbar
aus der Liste entfernen. Sorgen Sie beim Schließen eines
Ausgabefensters ebenfalls für die ord-nungsgemäße Beendigung der Ausgabe im Fenster
Hoffe das hilft euch mehr als mir
Hmnaja. Du hast also nicht diese angedeuteten Referenzen
public BildDokumentAusgabe Bild;
public MP3DokumentAusgabe MP3;
public TonDokumentAusgabe Ton;
? Der Code ist halt schon arg unübersichtlich… Wo werden denn die verschiedenen Fenster erzeugt?
Allgemein klingt das ein bißchen nach sowas wie
class Hauptfenster
{
private List<JFrame> openWindows = new ArrayList<JFrame>();
public void createSomeWindow()
{
SomeWindow w = new SomeWindow();
w.setVisible(true);
openWindows.add(w);
}
public void closeAllWindows() // Wird aus der actionPerformed des "Alle-Schließen"-Buttons aufgerufen
{
for(Iterator<JFrame> it = openWindows .iterator() ; it.hasNext() ; )
{
JFrame f = it.next();
f.dispose();
it.remove();
}
}
}
FALLS das so gemeint ist, müßte man da aber noch etwas basteln: Die Fenster sollten auch aus der “openWindows”-Liste entfernt werden, wenn man sie durch einen Klick auf ihr “Schließen-Kreuzchen” schließt. Dazu bräuchte man einen WindowListener, und ggf. müßte die “closeAllWindows”-Methode dann auch anders aussehen.
Insgesamt ist einiges davon IMHO unnötig kompliziert und krampfig. Das mit einem Iterator zu machen…bläh kopfschüttel
Wie auch immer. Vielleicht wäre es hilfreich, wenn du mal NUR diese Funktionalität der Fenster-Verwaltung in einem mini-Beispiel (wie oben angedeutet, mit Dummy-Klassen wie ‘SomeWindow’) implementieren würdest, um zu sehen, wie man das am besten machen könnte. Wenn das funktioniert, sollte es nicht mehr schwer sein, das auf das eigentliche Programm zu übertragen.
Hir ist ein beispiel für Bildausgabe denkemal sowas meintest du?
public class BildDokumentAusgabe extends JFrame {
private Image bild;
private String bildName;
private int topInset;
private Main m;
public BildDokumentAusgabe(BildDokument bildDokument) {
bildName = bildDokument.getName();
this.setTitle("Bilddokumentausgabe");
this.addWindowListener(new DokumentAusgabeEventHandler());
//this.setSize(300,300);
//setLocationRelativeTo(getParent());
//this.setVisible(true);
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);
}
// an dieser Stelle wird noch das Zeichnen
// implementiert (vgl. weiteren Text der Lektion)
this.setContentPane(new JPanel() {
@Override
public void paintComponent(Graphics g) {
if (bild.getHeight(this) > -1)
g.drawImage(bild, 0, 0, this);
}
});
this.setVisible(true);
}
/*
* Hierher die Methode "bildLaden" aus "MediendateienAusgeben" kopieren.
*
* Auch die Methode "limitSize" muss hierher kopiert werden!
*/
private boolean bildLaden(String 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() + "
beim Laden des Bildes \""
+ filePath);
return false;
}
}
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;
// hier fehlt noch die Skalierung
return new Dimension(scaledWidth, scaledHeight + this.topInset);
} else
return new Dimension(width, height + this.topInset);
}
}```
```/**
* Dokumentenklasse für Bilddokumente. Sie implementiert die in der Basisklasse
* "Dokument" spezifizierte Methode "dokumentAusgeben".
*/
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);
}
}```
```public class DokumentAusgabeEventHandler extends WindowAdapter {
@Override
public void windowClosing(WindowEvent we) {
Window w = we.getWindow();
//((DokumentAusgabeIF) w).ausgabeBeenden();
w.dispose();
}
}```
Hirmit schließe ich alle Fenster. Immerhin solangsamm komm ich näher
```for(Window win : Window.getWindows()){
win.setVisible(false);
//dispose();
}```Ich meinte eigentlich „leere“ Frames, um nur mal die Funktionalität mit dem Öffnen/Schließen zu testen. Zumindest klang die Aufgabenstellung für mich so, als sollte es eine Liste geben, in der IMMER genau die offenen Fenster enthalten sind. Aber
Ich dachte, damit wäre GROB sowas gemeint
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
public class MultiFrameTest
{
public static void main(String[] args)
{
SwingUtilities.invokeLater(new Runnable()
{
@Override
public void run()
{
createAndShowGUI();
}
});
}
private static void createAndShowGUI()
{
MainFrame mainFrame = new MainFrame();
mainFrame.setVisible(true);
}
}
class MainFrame extends JFrame
{
// Always stores all currently open SubFrames
private List<JFrame> subFrames = new ArrayList<JFrame>();
public MainFrame()
{
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel panel = new JPanel(new GridLayout(0, 1));
JButton addButton = new JButton("Add");
addButton.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
createNewSubFrame();
}
});
panel.add(addButton);
JButton closeAllButton = new JButton("Close all");
closeAllButton.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
closeAll();
}
});
panel.add(closeAllButton);
getContentPane().add(panel);
setBounds(0, 0, 200,100);
}
private void createNewSubFrame()
{
// Create a new SubFrame
final SubFrame subFrame = new SubFrame();
// Add a Listener: When the SubFrame is closed,
// it is also removed from the List
subFrame.addWindowListener(new WindowAdapter()
{
@Override
public void windowClosing(WindowEvent e)
{
subFrames.remove(subFrame);
System.out.println(subFrame+" was closed and removed from list, list now: "+subFrames);
}
});
// Add the SubFrame to the list
subFrames.add(subFrame);
subFrame.setVisible(true);
System.out.println("List after adding "+subFrame+" is : "+subFrames);
}
private void closeAll()
{
// Always close the first SubFrame and remove it from
// the list. Do this until the list is empty.
while (subFrames.size() > 0)
{
JFrame frame = subFrames.get(0);
frame.dispose();
subFrames.remove(frame);
System.out.println("Disposed "+frame+" list now: "+subFrames);
}
}
}
// A dummy frame
class SubFrame extends JFrame
{
private static int instanceCounter = 0;
private int instance;
SubFrame()
{
instance = instanceCounter++;
getContentPane().add(new JLabel("SubFrame "+instance));
pack();
setLocation(200+instance*20, instance*20);
}
@Override
public String toString()
{
return "SubFrame "+instance;
}
}