Get the screen device information of the display where the JFrame is currently located

Question

I'm trying to find out on which of my two displays a JFrame is.

I appreciate any help ;)

Answer 1

Sometimes I appreciate the later solutions (posted even years after the question was asked). This is my more complex solution of the same problem (originally based on Oracle documentation)…

Enjoy…

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

Definition of a helper class:

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

Definition of the method that does the job:

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

The redefinition of the DeviceConfig class in the context of the null return value (mentioned in comments above):

// ***
// 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 for all readers: You can simplify (or advance) this example to fit your needs…

(I hope it helps… ;-) )

Answer 2

Use getLocation() to get the coordinates of the top left of the frame. Based on your screen layout and resolution you will have to calculate which screen it is on.

What might also be helpful is to get the total dimension of the screens by using this:

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