Pokaż JFrame na określonym ekranie w konfiguracji z dwoma monitorami

Question

Mam konfigurację z podwójnym monitorem i chcę uruchomić mój GUI na określonym monitorze, jeśli zostanie znaleziony. Próbowałem utworzyć okno JFrame przekazując obiekt GraphicConfiguration mojego urządzenia ekranowego, ale nie działa, ramka nadal wyświetla się na ekranie głównym.

Jak ustawić ekran, na którym musi być wyświetlana moja ramka?

Answer 1

public static void showOnScreen(int screen, JFrame frame) 
{ 
    GraphicsEnvironment ge = GraphicsEnvironment 
     .getLocalGraphicsEnvironment(); 
    GraphicsDevice[] gs = ge.getScreenDevices(); 
    if(screen > -1 && screen < gs.length) 
    { 
     gs[screen].setFullScreenWindow(frame); 
    } 
    else if(gs.length > 0) 
    { 
     gs[0].setFullScreenWindow(frame); 
    } 
    else 
    { 
     throw new RuntimeException("No Screens Found"); 
    } 
} 

Answer 2

Moje doświadczenie obejmuje rozszerzanie pulpitów na wielu monitorach, a także konfigurowanie monitorów jako oddzielnych (X11) ekranów. Jeśli to nie jest to, co chcesz zrobić, nie będzie to miało zastosowania.

I moje rozwiązanie było trochę hackerem: zadzwoniłem pod numer Toolkit.getScreenSize(), ustaliłem, czy byłem w sytuacji wielomonitorowej (porównując wysokość do szerokości i przyjmując, że szerokość> dwukrotna wysokość wskazała na multi-monitor), to ustawienie początkowej pozycji X i Y ramki.

Answer 3

Proszę zapoznać się z GraphicsDevice API, masz na to dobry przykład.

Answer 4

Mam zmodyfikowano @ odpowiedź Joseph-Gordon, aby pozwolić na drodze do osiągnięcia tego celu bez wymuszania na pełnym ekranie:

public static void showOnScreen(int screen, JFrame frame) { 
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); 
    GraphicsDevice[] gd = ge.getScreenDevices(); 
    if(screen > -1 && screen < gd.length) { 
     frame.setLocation(gd[screen].getDefaultConfiguration().getBounds().x, frame.getY()); 
    } else if(gd.length > 0) { 
     frame.setLocation(gd[0].getDefaultConfiguration().getBounds().x, frame.getY()); 
    } else { 
     throw new RuntimeException("No Screens Found"); 
    } 
} 

W tym kodzie jestem zakładając getDefaultConfiguration() nigdy nie zwróci null. Jeśli tak nie jest, to proszę, popraw mnie. Ale ten kod działa, aby przenieść twój JFrame na żądany ekran.

Answer 5

Dla mnie również pracował dobrze (zakładając lewy monitor posiada rozmiar 1920x1200):

A) ustawić na lewym monitorze na jakiejś dokładnej pozycji:

newFrame.setBounds(200,100,400,200)

B) ustawić na prawym monitorze na niektóre dokładne położenie:

newFrame.setBounds(2000,100,200,100)

c) ustala się na lewym ekranie maksymalną:

newFrame.setBounds(200,100,400,200) newFrame.setExtendedState(JFrame.MAXIMIZED_BOTH)

D) ustawić na prawym monitorze zmaksymalizowane

newFrame.setBounds(2000,100,200,100) newFrame.setExtendedState(JFrame.MAXIMIZED_BOTH)

Answer 6

Znacznie czystsze rozwiązanie po przeczytaniu docs dla JFrame.setLocationRelativeTo wyświetlane na ekranie 2

public void moveToScreen() { 
    setVisible(false); 
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); 
    GraphicsDevice[] screens = ge.getScreenDevices(); 
    int n = screens.length; 
    for (int i = 0; i < n; i++) { 
     if (screens[i].getIDstring().contentEquals(settings.getScreen())) { 
      JFrame dummy = new JFrame(screens[i].getDefaultConfiguration()); 
      setLocationRelativeTo(dummy); 
      dummy.dispose(); 
     } 
    } 
    setVisible(true); 
} 

Ta funkcja może być używana do przełączania okna aplikacji między ekranami.

Answer 7

Wiele z tych rozwiązań działa w przypadku rozszerzonych wyświetlaczy. Jeśli korzystasz z oddzielnych ekranów, wystarczy przekazać obiekt konfiguracji graficznej pożądanego urządzenia graficznego do konstruktora jframe lub jdialog.

Answer 8

Odpowiedź Vickys zawiera odpowiedni wskaźnik. Jest to nowa JFrame (GraphicsConfiguration gc), która to robi.

Można to zrobić tak:

GraphicsDevice otherScreen = getOtherScreen(this); 
JFrame frameOnOtherScreen = new JFrame(otherScreen.getDefaultConfiguration()); 

private GraphicsDevice getOtherScreen(Component component) { 
    GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment(); 
    if (graphicsEnvironment.getScreenDevices().length == 1) { 
     // if there is only one screen, return that one 
     return graphicsEnvironment.getScreenDevices()[0]; 
    } 

    GraphicsDevice theWrongOne = component.getGraphicsConfiguration().getDevice(); 
    for (GraphicsDevice dev : graphicsEnvironment.getScreenDevices()) { 
     if (dev != theWrongOne) { 
      return dev; 
     } 
    } 

    return null; 
} 

Answer 9

Jesli chcesz ustawić go na środku lewej stronie ekranu:

int halfScreen = (int)(screenSize.width/2); 
       frame.setLocation((halfScreen - frame.getSize().width)/2, (screenSize.height - frame.getSize().height)/2); 

Jesli chcesz ustawić go na środku prawej części ekranu:

int halfScreen = (int)(screenSize.width/2); 
       frame.setLocation((halfScreen - frame.getSize().width)/2 + halfScreen, (screenSize.height - frame.getSize().height)/2); 

Answer 10

Mam zmodyfikowaną odpowiedź @ Joseph-gordon i @ryvantage, aby umożliwić sposób na osiągnięcie tego bez wymuszania pełnego sc reen, pozycja konfiguracja samego ekranu i ośrodek go na ekranie wyboru:

public void showOnScreen(int screen, JFrame frame) { 
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); 
    GraphicsDevice[] gd = ge.getScreenDevices(); 
    int width = 0, height = 0; 
    if(screen > -1 && screen < gd.length) { 
     width = gd[screen].getDefaultConfiguration().getBounds().width; 
     height = gd[screen].getDefaultConfiguration().getBounds().height; 
     frame.setLocation(
      ((width/2) - (frame.getSize().width/2)) + gd[screen].getDefaultConfiguration().getBounds().x, 
      ((height/2) - (frame.getSize().height/2)) + gd[screen].getDefaultConfiguration().getBounds().y 
     ); 
     frame.setVisible(true); 
    } else { 
     throw new RuntimeException("No Screens Found"); 
    } 
} 

Answer 11

ze wszystkimi wykruszanie się z ich własnych smaków, w oparciu o inne smaki, I dodać mój bo inni zablokowana cię w odniesieniu do pozycjonowanie okna na wybranym ekranie.

Jest po prostu najlepszy. Umożliwia także ustawienie lokalizacji na drugim ekranie.

public void setLocation(int screen, double x, double y) { 
     GraphicsEnvironment g = GraphicsEnvironment.getLocalGraphicsEnvironment(); 
     GraphicsDevice[] d = g.getScreenDevices(); 

     if (screen >= d.length) { 
       screen = d.length - 1; 
     } 

     Rectangle bounds = d[screen].getDefaultConfiguration().getBounds(); 

     // Is double? 
     if (x == Math.floor(x) && !Double.isInfinite(x)) { 
       x *= bounds.x; // Decimal -> percentage 
     } 
     if (y == Math.floor(y) && !Double.isInfinite(y)) { 
       y *= bounds.y; // Decimal -> percentage 
     } 

     x = bounds.x  + x; 
     y = jframe.getY() + y; 

     if (x > bounds.x) x = bounds.x; 
     if (y > bounds.y) y = bounds.y; 

     // If double we do want to floor the value either way 
     jframe.setLocation((int)x, (int)y); 
} 

Przykład:

setLocation(2, 200, 200); 

Nawet pozwala przechodzić w procentach dla położenia ekranu! Ekran

setLocation(2, 0.5, 0);  // Place on right edge from the top down if combined with setSize(50%, 100%); 

musi być większy niż 0, co, jestem pewien, jest trudnym wymogiem!

Aby umieścić na końcu, wystarczy zadzwonić pod numer Integer.MAX_VALUE. **