Come portare una finestra in primo piano?

Abbiamo un'applicazione Java che deve essere portata in primo piano quando un meccanismo di telecontrollo attiva qualcosa nell'applicazione.

Per ottenere ciò, abbiamo realizzato nel metodo chiamato della classe che rappresenta il frame della nostra applicazione (estensione di a JFrame) seguente implementazione:

setVisible(true);
toFront();

In Windows XP, funziona la prima volta che viene richiamato, la seconda volta lampeggia solo la scheda nella barra delle applicazioni, la cornice non viene più in primo piano. Lo stesso vale per Win2k. Su Vista sembra funzionare bene.

Hai qualche idea?

Una possibile soluzione è:

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

Ho avuto lo stesso problema portando a JFramein primo piano in Ubuntu (Java 1.6.0_10). E l'unico modo per risolverlo è fornire un file WindowListener. In particolare, ho dovuto impostare my JFramein modo che rimanga sempre in primo piano ogni volta che toFront()viene invocato e fornire un windowDeactivatedgestore di eventi a setAlwaysOnTop(false).

Quindi, ecco il codice che potrebbe essere inserito in una base JFrame, che viene utilizzato per derivare tutti i frame dell'applicazione.

@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);
}

Ogni volta che la tua cornice deve essere visualizzata o portata in prima chiamata frame.setVisible(true).

Da quando sono passato a Ubuntu 9.04 non sembra esserci bisogno di avere un WindowListenerinvocare super.setAlwaysOnTop(false)- come si può osservare; questo codice è stato spostato nei metodi toFront()e setVisible().

Si noti che il metodo setVisible()deve essere sempre invocato su EDT.

Windows ha la funzione di impedire alle finestre di rubare il focus; invece lampeggia l'icona sulla barra delle applicazioni. In XP è attivo per impostazione predefinita (l'unico posto che ho visto per cambiarlo è usare TweakUI, ma c'è un'impostazione del registro da qualche parte). In Vista potrebbero aver modificato l'impostazione predefinita e / o mostrata come un'impostazione accessibile all'utente con l'interfaccia utente predefinita.

Impedire alle finestre di forzarsi in primo piano e di concentrarsi è una funzionalità da Windows 2K (e io, per esempio, ne sono grato).

Detto questo, ho una piccola app Java che uso per ricordarmi di registrare le mie attività mentre lavoro, e si rende la finestra attiva ogni 30 minuti (configurabile, ovviamente). Funziona sempre in modo coerente con Windows XP e non lampeggia mai la finestra della barra del titolo. Utilizza il codice seguente, chiamato nel thread dell'interfaccia utente in seguito all'attivazione di un evento timer:

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

(la prima riga ripristina se minimizzata ... effettivamente la ripristinerebbe anche se ingrandita, ma non l'ho mai così).

Sebbene di solito questa app sia ridotta a icona, molto spesso è semplicemente dietro il mio editor di testo. E, come ho detto, funziona sempre.

Ho un'idea su quale potrebbe essere il tuo problema - forse hai una condizione di gara con la chiamata setVisible (). toFront () potrebbe non essere valido a meno che la finestra non sia effettivamente visualizzata quando viene chiamata; Ho già avuto questo problema con requestFocus (). Potrebbe essere necessario inserire la chiamata toFront () in un listener dell'interfaccia utente su un evento attivato dalla finestra.

07/09/2014: Ad un certo punto nel tempo il codice sopra ha smesso di funzionare, forse in Java 6 o 7. Dopo alcune indagini e sperimentazioni ho dovuto aggiornare il codice per sovrascrivere il toFrontmetodo della finestra (insieme al codice modificato da cosa è sopra):

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);
}

A partire da Java 8_20, questo codice sembra funzionare correttamente.

Ecco un metodo che funziona DAVVERO (testato su Windows Vista): D

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

La variabile a schermo intero indica se desideri che l'app venga eseguita a schermo intero o in finestra.

Questo non fa lampeggiare la barra delle applicazioni, ma porta la finestra in primo piano in modo affidabile.

Hj, tutti i tuoi metodi non funzionano per me, in Fedora KDE 14. Ho un modo sporco per portare una finestra in primo piano, mentre aspettiamo che Oracle risolva questo problema.

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);
      }
    }
  }

  //...

}

E questo funziona perfettamente nella mia Fedora KDE 14 :-)

Questo semplice metodo ha funzionato perfettamente per me in Windows 7:

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

Ho testato le tue risposte e solo quella di Stefan Reich ha funzionato per me. Anche se non sono riuscito a ripristinare la finestra al suo stato precedente (ingrandito / normale). Ho trovato meglio questa mutazione:

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

Questo è setState invece di setExtendedState.

Il modo più semplice che ho scoperto che non presenta incongruenze tra le piattaforme:

setVisible (false); setVisible (true);

Le regole che governano cosa succede quando si .toFront () un JFrame sono le stesse in Windows e in Linux:

-> se una finestra dell'applicazione esistente è attualmente la finestra focalizzata, lo stato attivo passa alla finestra richiesta -> in caso contrario, la finestra lampeggia semplicemente nella barra delle applicazioni

MA :

-> le nuove finestre si concentrano automaticamente

Quindi sfruttiamo questo! Vuoi portare una finestra in primo piano, come si fa? Bene :

1. Crea una finestra senza scopo vuota
2. Mostralo
3. Aspetta che venga visualizzato sullo schermo (setVisible lo fa)
4. Quando viene visualizzato, richiedere lo stato attivo per la finestra su cui si desidera effettivamente portare lo stato attivo
5. nascondi la finestra vuota, distruggila

Oppure, in codice java:

// 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);
  }
});

Ci sono numerosi avvertimenti nel javadoc per il metodo toFront () che potrebbero causare il tuo problema.

Ma cercherò comunque di indovinare, quando "lampeggia solo la scheda nella barra delle applicazioni", l'applicazione è stata ridotta a icona? In tal caso, potrebbe essere applicata la seguente riga del javadoc:

"Se questa finestra è visibile, porta questa finestra in primo piano e può renderla la finestra focalizzata."

Per evitare che la finestra perda il focus quando ritorna visibile dopo essere stata nascosta, tutto ciò che serve è:

setExtendedState(JFrame.NORMAL);

Così:

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