Obtenir les informations de l'écran de l'affichage où le JFrame est actuellement situé

Question

J'essaie de savoir sur lequel de mes deux affichages un JFrame est.

Je vous remercie de toute aide;)

Answer 1

Utilisez getLocation() pour obtenir les coordonnées du coin supérieur gauche du cadre. En fonction de la disposition et de la résolution de votre écran, vous devrez calculer sur quel écran il se trouve.

Ce qui pourrait être utile est aussi d'obtenir la dimension totale des écrans en utilisant ceci:

Dimension dim = Toolkit.getDefaultToolkit().getScreenSize(); 

Answer 2

Parfois, j'apprécie les solutions plus tard (affichés même des années après on a posé la question). Ceci est ma solution plus complexe du même problème (à l'origine basé sur la documentation Oracle) ...

Profitez ...

// First some imports (it could spare your time)… 
import java.awt.GraphicsConfiguration; 
import java.awt.GraphicsDevice; 
import java.awt.GraphicsEnvironment; 
import java.awt.Rectangle; 
import java.awt.Window; 

Définition d'une classe d'aide:

/** 
* This class just stores indexes and instances of a graphics device and 
* one of its configurations (within current graphics environment). 
*/ 
public class DeviceConfig 
{ 
    public int deviceIndex = 0; 
    public int configIndex = 0; 
    public GraphicsDevice device = null; 
    public GraphicsConfiguration config = null; 
} 

Définition de la méthode qui fait le travail:

/** 
* This method finds the graphics device and configuration by the location 
* of specified window. 
* 
* @param window the window for which should be the identified the graphics 
*     device and configuration 
* @return instance of custom class type (DeviceConfig) that stores the 
*   indexes and instances of graphics device and configuration of 
*   current graphics environment 
*/ 
public DeviceConfig findDeviceConfig(Window window) 
{ 
    // Prepare default return value: 
    DeviceConfig deviceConfig = new DeviceConfig(); 

    // More correct would be to return null when no device or configuration 
    // has been found: 
    // 
    // DeviceConfig deviceConfig = null; 
    // 
    // See also the comments marked by *** (below). 

    Rectangle windowBounds = window.getBounds(); 
    int lastArea = 0; 

    GraphicsEnvironment graphicsEnvironment = 
     GraphicsEnvironment.getLocalGraphicsEnvironment(); 

    GraphicsDevice[] graphicsDevices = 
     graphicsEnvironment.getScreenDevices(); 

    // Search through all devices… 
    for (int i = 0; i < graphicsDevices.length; ++i) 
    { 
     GraphicsDevice graphicsDevice = graphicsDevices[i]; 

     GraphicsConfiguration[] graphicsConfigurations = 
      graphicsDevice.getConfigurations(); 

     // It is possible that your device will have only one configuration, 
     // but you cannot rely on this(!)… 
     for (int j = 0; j < graphicsConfigurations.length; ++j) 
     { 
      GraphicsConfiguration graphicsConfiguration = 
       graphicsConfigurations[j]; 

      Rectangle graphicsBounds = 
       graphicsConfiguration.getBounds(); 

      Rectangle intersection = windowBounds. 
       intersection(graphicsBounds); 

      int area = intersection.width * intersection.height; 

      if (0 != area) 
      { 
       // *** 
       // The block of code in this comments is relevant in case you 
       // want to return the null value when no device or 
       // configuration has been found. 
       /* 
       if (null == deviceConfig) 
       { 
        // In this case the better solution would be to declare 
        // the full constructor in the DeviceClass (see below) and 
        // use it here like this: 

        deviceConfig = new DeviceConfig(i, j, 
         graphicsDevice, graphicsConfiguration); 

        // (but the current solution is more simple when no 
        // constructor is defined)… 

       } 
       else 
       */ 

       if (area > lastArea) 
       { 
        lastArea = area; 
        deviceConfig.deviceIndex = i; 
        deviceConfig.configIndex = j; 
        deviceConfig.device = graphicsDevice; 
        deviceConfig.config = graphicsConfiguration; 
       } 
      } 
     } 
    } 

    return deviceConfig; 
} 

La redéfinition du DeviceConfig c lass dans le contexte de la valeur null de retour (mentionné dans les commentaires ci-dessus):

// *** 
// The DeviceConfig class with constructors would look like this: 

public class DeviceConfig 
{ 
    public int deviceIndex; 
    public int configIndex; 
    public GraphicsDevice device; 
    public GraphicsConfiguration config; 

    /** The default constructor. (Would not be used in the second case.) */ 
    public DeviceConfig() 
    { 
     deviceIndex = 0; 
     configIndex = 0; 
     device = null; 
     config = null; 
    } 

    /** The full constructor. */ 
    public DeviceConfig(int i, int j, 
     GraphicsDevice graphicsDevice, 
     GraphicsConfiguration graphicsConfiguration) 
    { 
     deviceIndex = i; 
     configIndex = j; 
     device = graphicsDevice; 
     config = graphicsConfiguration; 
    } 
} 

---

Post Scriptum pour tous les lecteurs: Vous pouvez simplifier (ou avance) cet exemple pour répondre à vos besoins ...

(J'espère que cela aide ... ;-))