Como trazer uma janela para a frente?

Temos um aplicativo Java que precisa ser colocado em primeiro plano quando um mecanismo de telecontrole ativa algo no aplicativo.

Para conseguir isso, percebemos no método chamado da classe que representa a estrutura de nossa aplicação (extensão de a JFrame) após a implementação:

setVisible(true);
toFront();

No Windows XP isso funciona na primeira vez que é chamado, na segunda vez apenas a guia da barra de tarefas pisca, o quadro não vem mais para a frente. O mesmo vale para Win2k. No Vista parece funcionar bem.

Você tem alguma ideia?

Uma possível solução é:

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

Eu tive o mesmo problema ao trazer um JFramepara a frente no Ubuntu (Java 1.6.0_10). E a única maneira de resolver isso é fornecendo um WindowListener. Especificamente, tive que definir meu JFramepara ficar sempre no topo sempre que toFront()for invocado e fornecer windowDeactivatedum manipulador de eventos para setAlwaysOnTop(false).

Portanto, aqui está o código que pode ser colocado em uma base JFrame, que é usado para derivar todos os quadros de aplicativos.

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

Sempre que seu porta-retratos deve ser exibido ou colocado em primeiro plano frame.setVisible(true).

Desde que mudei para o Ubuntu 9.04, parece não haver necessidade de ter um WindowListenerpara invocar super.setAlwaysOnTop(false)- como pode ser observado; este código foi movido para os métodos toFront()e setVisible().

Observe que o método setVisible()sempre deve ser chamado em EDT.

O Windows tem a facilidade de evitar que as janelas roubem o foco; em vez disso, ele pisca o ícone da barra de tarefas. No XP, ele está ativado por padrão (o único lugar que vi para alterá-lo é usando o TweakUI, mas há uma configuração de registro em algum lugar). No Vista, eles podem ter alterado o padrão e / ou exposto como uma configuração acessível ao usuário com a interface do usuário pronta para usar.

Evitar que as janelas se forcem para a frente e obtenham o foco é um recurso desde o Windows 2K (e eu, por exemplo, sou grato por isso).

Dito isso, tenho um pequeno aplicativo Java que uso para me lembrar de registrar minhas atividades enquanto trabalho e torna-se a janela ativa a cada 30 minutos (configurável, claro). Ele sempre funciona de forma consistente no Windows XP e nunca pisca a janela da barra de título. Ele usa o seguinte código, chamado no thread de IU como resultado de um evento de timer disparado:

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

(a primeira linha é restaurada se minimizada ... na verdade ela restauraria se maximizada também, mas eu nunca fiz isso).

Embora eu geralmente tenha este aplicativo minimizado, muitas vezes ele está simplesmente atrás do meu editor de texto. E, como eu disse, sempre funciona.

Tenho uma ideia de qual poderia ser o seu problema - talvez você tenha uma condição de corrida com a chamada setVisible (). toFront () pode não ser válido a menos que a janela seja realmente exibida quando for chamada; Eu tive esse problema com requestFocus () antes. Você pode precisar colocar a chamada toFront () em um ouvinte da IU em um evento ativado por janela.

07-09-2014: Em algum ponto no tempo, o código acima parou de funcionar, talvez em Java 6 ou 7. Depois de alguma investigação e experimentação, tive que atualizar o código para substituir o toFrontmétodo da janela, fazer isso (em conjunto com o código modificado de que está acima):

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 do Java 8_20, esse código parece estar funcionando bem.

Aqui está um método que REALMENTE funciona (testado no Windows Vista): D

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

A variável fullscreen indica se você deseja que o aplicativo seja executado em tela inteira ou em janela.

Isso não pisca a barra de tarefas, mas traz a janela para a frente de forma confiável.

Hj, todos os seus métodos não estão funcionando para mim, no Fedora KDE 14. Eu tenho uma maneira suja de trazer uma janela para a frente, enquanto esperamos que o Oracle conserte esse 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 isso funciona perfeitamente no meu Fedora KDE 14 :-)

Este método simples funcionou perfeitamente para mim no Windows 7:

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

Testei suas respostas e apenas a de Stefan Reich funcionou para mim. Embora eu não tenha conseguido restaurar a janela ao seu estado anterior (maximizada / normal). Eu achei esta mutação melhor:

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

Isso é em setStatevez de setExtendedState.

A maneira mais simples que descobri que não tem inconsistência entre as plataformas:

setVisible (false); setVisible (true);

As regras que regem o que acontece quando você .toFront () um JFrame são as mesmas no Windows e no Linux:

-> se uma janela do aplicativo existente for atualmente a janela em foco, então o foco muda para a janela solicitada -> se não, a janela simplesmente pisca na barra de tarefas

MAS :

-> novas janelas obtêm foco automaticamente

Então, vamos explorar isso! Você quer trazer uma janela para a frente, como fazer? Bem :

1. Crie uma janela vazia sem finalidade
2. Mostre
3. Espere até que apareça na tela (setVisible faz isso)
4. Quando mostrado, solicite o foco para a janela para a qual você realmente deseja trazer o foco
5. esconda a janela vazia, destrua-a

Ou, em 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);
  }
});

Existem várias advertências no javadoc para o método toFront () que podem estar causando o problema.

Mas vou adivinhar de qualquer maneira, quando "apenas a guia na barra de tarefas piscar", o aplicativo foi minimizado? Nesse caso, a seguinte linha do javadoc pode ser aplicada:

"Se esta janela estiver visível, traz esta janela para a frente e pode torná-la a janela em foco."

Para evitar que a janela perca o foco ao voltar a ficar visível após ser escondida, tudo o que é necessário é:

setExtendedState(JFrame.NORMAL);

Igual a:

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