Wie bringt man ein Fenster nach vorne?

Wir haben eine Java-Anwendung, die in den Vordergrund gerückt werden muss, wenn ein Telekontrollmechanismus etwas in der Anwendung aktiviert.

Um dies zu erreichen, haben wir in der aufgerufenen Methode der Klasse, die den Rahmen unserer Anwendung darstellt (Erweiterung von a JFrame), folgende Implementierung realisiert:

setVisible(true);
toFront();

Unter Windows XP funktioniert dies beim ersten Aufruf. Beim zweiten Mal blinkt nur die Registerkarte in der Taskleiste. Der Rahmen wird nicht mehr nach vorne verschoben. Gleiches gilt für Win2k. Unter Vista scheint es gut zu funktionieren.

Hast du eine Idee?

Eine mögliche Lösung ist:

java.awt.EventQueue.invokeLater(new Runnable() {
    @Override
    public void run() {
        myFrame.toFront();
        myFrame.repaint();
    }
});

Ich hatte das gleiche Problem damit JFrame, unter Ubuntu (Java 1.6.0_10) ein nach vorne zu bringen. Und der einzige Weg, wie ich es lösen könnte, ist die Bereitstellung eines WindowListener. Insbesondere musste ich meine so einstellen JFrame, dass sie immer auf dem neuesten Stand toFront()ist, wenn sie aufgerufen wird, und windowDeactivatedEvent-Handler bereitstellen setAlwaysOnTop(false).

Hier ist also der Code, der in eine Basis JFrameeingefügt werden kann, mit der alle Anwendungsrahmen abgeleitet werden.

@Override
public void setVisible(final boolean visible) {
  // make sure that frame is marked as not disposed if it is asked to be visible
  if (visible) {
      setDisposed(false);
  }
  // let's handle visibility...
  if (!visible || !isVisible()) { // have to check this condition simply because super.setVisible(true) invokes toFront if frame was already visible
      super.setVisible(visible);
  }
  // ...and bring frame to the front.. in a strange and weird way
  if (visible) {
      toFront();
  }
}

@Override
public void toFront() {
  super.setVisible(true);
  int state = super.getExtendedState();
  state &= ~JFrame.ICONIFIED;
  super.setExtendedState(state);
  super.setAlwaysOnTop(true);
  super.toFront();
  super.requestFocus();
  super.setAlwaysOnTop(false);
}

Wann immer Ihr Rahmen angezeigt oder zum Front Call gebracht werden soll frame.setVisible(true).

Seit ich zu Ubuntu 9.04 gewechselt bin, scheint es nicht nötig zu sein, ein WindowListenerzum Aufrufen zu haben super.setAlwaysOnTop(false)- wie zu beobachten ist; Dieser Code wurde in die Methoden toFront()und verschoben setVisible().

Bitte beachten Sie, dass die Methode setVisible()bei EDT immer aufgerufen werden sollte.

Windows kann verhindern, dass Fenster den Fokus stehlen. Stattdessen blinkt das Taskleistensymbol. In XP ist es standardmäßig aktiviert (der einzige Ort, an dem ich Änderungen vorgenommen habe, ist die Verwendung von TweakUI, aber irgendwo gibt es eine Registrierungseinstellung). In Vista haben sie möglicherweise die Standardeinstellung geändert und / oder sie als vom Benutzer zugängliche Einstellung mit der sofort einsatzbereiten Benutzeroberfläche verfügbar gemacht.

Seit Windows 2K ist es eine Funktion, zu verhindern, dass sich Fenster nach vorne zwingen und den Fokus übernehmen (und ich bin dankbar dafür).

Trotzdem habe ich eine kleine Java-App, mit der ich mich daran erinnere, meine Aktivitäten während der Arbeit aufzuzeichnen, und die sich alle 30 Minuten zum aktiven Fenster macht (natürlich konfigurierbar). Es funktioniert unter Windows XP immer konsistent und blinkt nie im Fenster der Titelleiste. Es verwendet den folgenden Code, der im UI-Thread als Ergebnis eines Timer-Ereignisauslösens aufgerufen wird:

if(getState()!=Frame.NORMAL) { setState(Frame.NORMAL); }
toFront();
repaint();

(Die erste Zeile wird wiederhergestellt, wenn sie minimiert wird ... tatsächlich würde sie wiederhergestellt, wenn sie ebenfalls maximiert wird, aber ich habe sie nie so).

Während ich diese App normalerweise minimiert habe, steht sie oft einfach hinter meinem Texteditor. Und wie gesagt, es funktioniert immer.

Ich habe eine Idee, was Ihr Problem sein könnte - vielleicht haben Sie eine Race-Bedingung mit dem Aufruf setVisible (). toFront () ist möglicherweise nur gültig, wenn das Fenster beim Aufruf tatsächlich angezeigt wird. Ich hatte dieses Problem schon einmal mit requestFocus (). Möglicherweise müssen Sie den Aufruf toFront () in einem UI-Listener für ein fensteraktiviertes Ereignis einfügen.

07.09.2014: Irgendwann funktionierte der obige Code nicht mehr, möglicherweise unter Java 6 oder 7. Nach einigen Untersuchungen und Experimenten musste ich den Code aktualisieren, um die toFrontMethode des Fensters zu überschreiben. Führen Sie dies aus (in Verbindung mit geändertem Code von was befindet sich über):

setVisible(true);
toFront();
requestFocus();
repaint();

...

public @Override void toFront() {
    int sta = super.getExtendedState() & ~JFrame.ICONIFIED & JFrame.NORMAL;

    super.setExtendedState(sta);
    super.setAlwaysOnTop(true);
    super.toFront();
    super.requestFocus();
    super.setAlwaysOnTop(false);
}

Ab Java 8_20 scheint dieser Code einwandfrei zu funktionieren.

Hier ist eine Methode, die WIRKLICH funktioniert (unter Windows Vista getestet): D.

   frame.setExtendedState(JFrame.ICONIFIED);
   frame.setExtendedState(fullscreen ? JFrame.MAXIMIZED_BOTH : JFrame.NORMAL);

Die Vollbildvariable gibt an, ob die App im Vollbildmodus oder im Fenster ausgeführt werden soll.

Dadurch blinkt die Taskleiste nicht, sondern das Fenster wird zuverlässig nach vorne gebracht.

Hj, alle Ihre Methoden funktionieren in Fedora KDE 14 nicht für mich. Ich habe eine schmutzige Möglichkeit, ein Fenster nach vorne zu bringen, während wir darauf warten, dass Oracle dieses Problem behebt.

import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.event.InputEvent;

public class FrameMain extends javax.swing.JFrame {

  //...
  private final javax.swing.JFrame mainFrame = this;

  private void toggleVisible() {
    setVisible(!isVisible());
    if (isVisible()) {
      toFront();
      requestFocus();
      setAlwaysOnTop(true);
      try {
        //remember the last location of mouse
        final Point oldMouseLocation = MouseInfo.getPointerInfo().getLocation();

        //simulate a mouse click on title bar of window
        Robot robot = new Robot();
        robot.mouseMove(mainFrame.getX() + 100, mainFrame.getY() + 5);
        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);

        //move mouse to old location
        robot.mouseMove((int) oldMouseLocation.getX(), (int) oldMouseLocation.getY());
      } catch (Exception ex) {
        //just ignore exception, or you can handle it as you want
      } finally {
        setAlwaysOnTop(false);
      }
    }
  }

  //...

}

Und das funktioniert perfekt in meinem Fedora KDE 14 :-)

Diese einfache Methode hat in Windows 7 perfekt funktioniert:

    private void BringToFront() {
        java.awt.EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                if(jFrame != null) {
                    jFrame.toFront();
                    jFrame.repaint();
                }
            }
        });
    }

Ich habe deine Antworten getestet und nur die von Stefan Reich hat für mich gearbeitet. Obwohl ich es nicht geschafft habe, das Fenster in seinen vorherigen Zustand zurückzusetzen (maximiert / normal). Ich fand diese Mutation besser:

view.setState(java.awt.Frame.ICONIFIED);
view.setState(java.awt.Frame.NORMAL);

Das ist setStatestatt setExtendedState.

Am einfachsten habe ich festgestellt, dass es keine plattformübergreifende Inkonsistenz gibt:

setVisible (false); setVisible (true);

Die Regeln, die festlegen, was passiert, wenn Sie .toFront () einen JFrame verwenden, sind in Windows und Linux identisch:

-> Wenn ein Fenster der vorhandenen Anwendung derzeit das fokussierte Fenster ist, wechselt der Fokus zum angeforderten Fenster. -> Wenn nicht, blinkt das Fenster lediglich in der Taskleiste

ABER :

-> Neue Fenster werden automatisch fokussiert

Also lasst uns das ausnutzen! Sie möchten ein Fenster nach vorne bringen, wie geht das? Gut :

1. Erstellen Sie ein leeres Nichtzweckfenster
2. Zeig es
3. Warten Sie, bis es auf dem Bildschirm angezeigt wird (setVisible macht das)
4. Wenn angezeigt, fordern Sie den Fokus für das Fenster an, auf das Sie den Fokus tatsächlich setzen möchten
5. verstecke das leere Fenster, zerstöre es

Oder im Java-Code:

// unminimize if necessary
this.setExtendedState(this.getExtendedState() & ~JFrame.ICONIFIED);

// don't blame me, blame my upbringing
// or better yet, blame java !
final JFrame newFrame = new JFrame();
newFrame.add(new JLabel("boembabies, is this in front ?"));

newFrame.pack();
newFrame.setVisible(true);
newFrame.toFront();

this.toFront();
this.requestFocus();

// I'm not 100% positive invokeLater is necessary, but it seems to be on
// WinXP. I'd be lying if I said I understand why
SwingUtilities.invokeLater(new Runnable() {
  @Override public void run() {
    newFrame.setVisible(false);
  }
});

Im Javadoc gibt es zahlreiche Einschränkungen für die Methode toFront (), die möglicherweise Ihr Problem verursachen.

Aber ich werde trotzdem raten, wenn "nur die Registerkarte in der Taskleiste blinkt", wurde die Anwendung minimiert? In diesem Fall kann die folgende Zeile aus dem Javadoc zutreffen:

"Wenn dieses Fenster sichtbar ist, wird dieses Fenster nach vorne gebracht und möglicherweise zum fokussierten Fenster."

Um zu vermeiden, dass das Fenster den Fokus verliert, wenn es nach dem Ausblenden wieder sichtbar wird, ist Folgendes erforderlich:

setExtendedState(JFrame.NORMAL);

Wie so:

defaultItem.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                showWindow();
                setExtendedState(JFrame.NORMAL);
            }
});