¿Cómo llevar una ventana al frente?

Tenemos una aplicación Java que se debe traer a un primer plano cuando un mecanismo de telecontrol activa algo en la aplicación.

Para ello, nos hemos dado cuenta en el método llamado de la clase que representa el marco de nuestra aplicación (extensión de a JFrame) siguiente implementación:

setVisible(true);
toFront();

En Windows XP, esto funciona la primera vez que se llama, la segunda vez solo parpadea la pestaña en la barra de tareas, el marco ya no aparece al frente. Lo mismo ocurre con Win2k. En Vista, parece funcionar bien.

¿Tienes alguna idea?

Una posible solución es:

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

Tuve el mismo problema al traer un JFrameal frente en Ubuntu (Java 1.6.0_10). Y la única forma en que podría resolverlo es proporcionando un WindowListener. Específicamente, tuve que configurar mi JFramepara que permaneciera siempre en la parte superior cada vez que toFront()se invocaba y proporcionar un windowDeactivatedcontrolador de eventos a setAlwaysOnTop(false).

Entonces, aquí está el código que podría colocarse en una base JFrame, que se usa para derivar todos los marcos de la aplicación.

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

Siempre que su marco deba mostrarse o llevarse al frente, llame frame.setVisible(true).

Desde que me mudé a Ubuntu 9.04, parece que no hay necesidad de tener una WindowListenerinvocación super.setAlwaysOnTop(false), como se puede observar; este código se movió a los métodos toFront()y setVisible().

Tenga en cuenta que el método setVisible()siempre debe invocarse en EDT.

Windows tiene la capacidad de evitar que las ventanas roben el foco; en su lugar, parpadea el icono de la barra de tareas. En XP está activado por defecto (el único lugar que he visto para cambiarlo es usando TweakUI, pero hay una configuración de registro en alguna parte). En Vista, es posible que hayan cambiado el valor predeterminado y / o lo hayan expuesto como una configuración accesible para el usuario con la interfaz de usuario lista para usar.

Evitar que las ventanas se fuercen al frente y se enfoquen es una característica desde Windows 2K (y yo, por mi parte, estoy agradecido por ello).

Dicho esto, tengo una pequeña aplicación de Java que uso para recordarme que registre mis actividades mientras trabajo, y se convierte en la ventana activa cada 30 minutos (configurable, por supuesto). Siempre funciona de manera uniforme en Windows XP y nunca muestra la ventana de la barra de título. Utiliza el siguiente código, llamado en el hilo de la IU como resultado de la activación de un evento de temporizador:

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

(la primera línea se restaura si se minimiza ... en realidad la restauraría si se maximizara también, pero nunca la tengo así).

Si bien normalmente tengo esta aplicación minimizada, a menudo está simplemente detrás de mi editor de texto. Y, como dije, siempre funciona.

Tengo una idea de cuál podría ser su problema; tal vez tenga una condición de carrera con la llamada setVisible (). toFront () puede no ser válido a menos que la ventana se muestre realmente cuando se llama; He tenido este problema con requestFocus () antes. Es posible que deba poner la llamada toFront () en un detector de IU en un evento activado por ventana.

2014-09-07: En algún momento, el código anterior dejó de funcionar, tal vez en Java 6 o 7. Después de investigar y experimentar, tuve que actualizar el código para anular el toFrontmétodo de la ventana para hacer esto (junto con el código modificado de lo que está arriba):

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 partir de Java 8_20, este código parece funcionar bien.

Aquí hay un método que REALMENTE funciona (probado en Windows Vista): D

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

La variable de pantalla completa indica si desea que la aplicación se ejecute en pantalla completa o en ventana.

Esto no hace parpadear la barra de tareas, pero trae la ventana al frente de manera confiable.

Hj, todos sus métodos no funcionan para mí, en Fedora KDE 14. Tengo una forma sucia de traer una ventana al frente, mientras esperamos que Oracle solucione este 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);
      }
    }
  }

  //...

}

Y esto funciona perfectamente en mi Fedora KDE 14 :-)

Este método simple funcionó para mí perfectamente en Windows 7:

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

Probé tus respuestas y solo la de Stefan Reich funcionó para mí. Aunque no pude restaurar la ventana a su estado anterior (maximizada / normal). Encontré mejor esta mutación:

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

Eso es en setStatelugar de setExtendedState.

La forma más sencilla que he encontrado que no tiene inconsistencias entre plataformas:

setVisible (falso); setVisible (verdadero);

Las reglas que rigen lo que sucede cuando .toFront () un JFrame son las mismas en Windows y en Linux:

-> si una ventana de la aplicación existente es actualmente la ventana enfocada, entonces el enfoque cambia a la ventana solicitada -> si no, la ventana simplemente parpadea en la barra de tareas

PERO :

-> las nuevas ventanas se enfocan automáticamente

¡Explotemos esto! Quieres traer una ventana al frente, ¿cómo hacerlo? Bien :

1. Crea una ventana vacía sin propósito
2. Enséñalo
3. Espere a que aparezca en la pantalla (setVisible lo hace)
4. Cuando se muestre, solicite el enfoque para la ventana a la que realmente desea llevar el enfoque
5. esconde la ventana vacía, destrúyela

O, en código 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);
  }
});

Existen numerosas advertencias en el javadoc para el método toFront () que pueden estar causando su problema.

Pero, de todos modos, haré una conjetura, cuando "solo parpadee la pestaña de la barra de tareas", ¿se ha minimizado la aplicación? Si es así, se puede aplicar la siguiente línea del javadoc:

"Si esta ventana es visible, trae esta ventana al frente y puede convertirla en la ventana enfocada".

Para evitar que la ventana pierda el foco cuando vuelva a ser visible después de estar oculta, todo lo que se necesita es:

setExtendedState(JFrame.NORMAL);

Al igual que:

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