Как выяснить, на каком экране отображается JDialog

у меня есть очень большое приложение, которое имеет множество диалогов. Моя задача - убедиться, что диалог, который не полностью виден (потому что пользователь вытащил его из видимой области экрана), перемещается обратно в центр экрана.

это не проблема, когда я имею дело только с одним экраном. Это работает просто отлично ... тем не менее, большинство пользователей этого приложения имеют два экрана на рабочем столе ...

когда я пытаюсь выяснить, на каком экране диалоговое окно показали и центр его на экране ... ну, на самом деле это центр, но на основном экране (который может не быть экраном, на котором отображается диалог).

чтобы показать вам, что мои мысли были до сих пор, вот код ... 

 /**
 * Get the number of the screen the dialog is shown on ...
 */
private static int getActiveScreen(JDialog jd) {
    int screenId = 1;
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice[] gd = ge.getScreenDevices();
    for (int i = 0; i < gd.length; i++) {
        GraphicsConfiguration gc = gd[i].getDefaultConfiguration();
        Rectangle r = gc.getBounds();
        if (r.contains(jd.getLocation())) {
            screenId = i + 1;
        }
    }
    return screenId;
}

/**
* Get the Dimension of the screen with the given id ...
*/
private static Dimension getScreenDimension(int screenId) {
    Dimension d = new Dimension(0, 0);
    if (screenId > 0) {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        DisplayMode mode = ge.getScreenDevices()[screenId - 1].getDisplayMode();
        d.setSize(mode.getWidth(), mode.getHeight());
    }
    return d;
}

/**
 * Check, if Dialog can be displayed completely ...
 * @return true, if dialog can be displayed completely
 */
private boolean pruefeDialogImSichtbarenBereich() {
    int screenId = getActiveScreen(this);
    Dimension dimOfScreen = getScreenDimension(screenId);
    int xPos = this.getX();
    int yPos = this.getY();
    Dimension dimOfDialog = this.getSize();
    if (xPos + dimOfDialog.getWidth() > dimOfScreen.getWidth() || yPos + dimOfDialog.getHeight() > dimOfScreen.getHeight()) {
        return false;
    }
    return true;
}

/**
 * Center Dialog...
 */
private void zentriereDialogAufMonitor() {
    this.setLocationRelativeTo(null);
}

во время отладки я наткнулся на тот факт, что getActiveScreen() похоже, не работает так, как я; кажется, всегда возвращается 2 (что является своего рода дерьмом, так как это означало бы, что диалог всегда отображается во втором монитор...что, конечно,неправда).

кто-нибудь знает, как центрировать мой диалог на экране, на котором он фактически показан?

7
center java jdialog multiple-monitors swing

3 ответов

код getActiveScreen метод работал, за исключением того, что он использовал экран, содержащий верхний левый угол окна. Если вы используете компонент.getGraphicsConfiguration () вместо этого, он даст вам, какой экран имеет большинство пикселей окна. setLocationRelativeTo(null) здесь нет помощи, потому что он всегда использует основной экран. Вот как это решить:

static boolean windowFitsOnScreen(Window w) {
    return w.getGraphicsConfiguration().getBounds().contains(w.getBounds());
}

static void centerWindowToScreen(Window w) {
    Rectangle screen = w.getGraphicsConfiguration().getBounds();
    w.setLocation(
        screen.x + (screen.width - w.getWidth()) / 2,
        screen.y + (screen.height - w.getHeight()) / 2
    );
}

затем вы можете сделать:

JDialog jd;
...
if (!windowFitsOnScreen(jd)) centerWindowToScreen(jd);

который будет центрировать диалог до ближайшего экрана (монитора). Возможно, Вам потребуется убедиться, что диалог первоначально отображается / позиционируется первым.

1

Я не уверен, насколько это будет полезно, но это код, который я использую при попытке определить графические устройства для windows.

Я немного обманываю, я склонен использовать Component и разрешить служебным методам либо найти окно верхнего уровня, либо использовать 's экран.

/**
 * Returns the GraphicsDevice that the specified component appears the most on.
 */
public static GraphicsDevice getGraphicsDevice(Component comp) {

    GraphicsDevice device = null;

    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice lstGDs[] = ge.getScreenDevices();

    ArrayList<GraphicsDevice> lstDevices = new ArrayList<GraphicsDevice>(lstGDs.length);
    if (comp != null && comp.isVisible()) {
        Rectangle parentBounds = comp.getBounds();

        /*
         * If the component is not a window, we need to find its location on the
         * screen...
         */
        if (!(comp instanceof Window)) {
            Point p = new Point(0, 0);
            SwingUtilities.convertPointToScreen(p, comp);
            parentBounds.setLocation(p);
        }

        for (GraphicsDevice gd : lstGDs) {
            GraphicsConfiguration gc = gd.getDefaultConfiguration();
            Rectangle screenBounds = gc.getBounds();
            if (screenBounds.intersects(parentBounds)) {
                lstDevices.add(gd);
            }
        }

        if (lstDevices.size() == 1) {
            device = lstDevices.get(0);
        } else {

            GraphicsDevice gdMost = null;
            float maxArea = 0;
            for (GraphicsDevice gd : lstDevices) {
                int width = 0;
                int height = 0;

                GraphicsConfiguration gc = gd.getDefaultConfiguration();
                Rectangle bounds = gc.getBounds();

                Rectangle2D intBounds = bounds.createIntersection(parentBounds);

                float perArea = (float) ((intBounds.getWidth() * intBounds.getHeight()) / (parentBounds.width * parentBounds.height));
                if (perArea > maxArea) {
                    maxArea = perArea;
                    gdMost = gd;
                }
            }

            if (gdMost != null) {
                device = gdMost;
            }
        }
    }
    return device;
}

/**
 * Returns the GraphicsDevice at the specified point
 */
public static GraphicsDevice getGraphicsDeviceAt(Point pos) {
    GraphicsDevice device = null;
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice lstGDs[] = ge.getScreenDevices();

    List<GraphicsDevice> lstDevices = new ArrayList<GraphicsDevice>(lstGDs.length);
    for (GraphicsDevice gd : lstGDs) {

        GraphicsConfiguration gc = gd.getDefaultConfiguration();
        Rectangle screenBounds = gc.getBounds();
        if (screenBounds.contains(pos)) {
            lstDevices.add(gd);
        }
    }

    if (lstDevices.size() > 0) {
        device = lstDevices.get(0);
    }

    return device;
}

/**
 * Returns the Point that would allow the supplied Window to be
 * centered on it's current graphics device.
 * 
 * It's VERY important that the Window be seeded with a location
 * before calling this method, otherwise it will appear on the 
 * device at 0x0
 *
 * @param window
 * @return
 */
public static Point centerOfScreen(Window window) {
    // Try and figure out which window we actually reside on...
    GraphicsDevice gd = getGraphicsDeviceAt(window.getLocation());
    GraphicsConfiguration gc = gd.getDefaultConfiguration();

    Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets(gd.getDefaultConfiguration());
    Rectangle bounds = gc.getBounds();
    Dimension size = bounds.getSize();

    size.width -= (screenInsets.left + screenInsets.right);
    size.height -= (screenInsets.top + screenInsets.bottom);

    int width = window.getWidth();
    int height = window.getHeight();

    int xPos = screenInsets.left + ((size.width - width) / 2);
    int yPos = screenInsets.top + ((size.height - height) / 2);

    return new Point(xPos, yPos);
}
1

вот код, используемый в центре окна.

  //Center the window
  Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
  Dimension frameSize = frame.getSize();
  if (frameSize.height > screenSize.height) {
    frameSize.height = screenSize.height;
  }
  if (frameSize.width > screenSize.width) {
    frameSize.width = screenSize.width;
  }
  frame.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2);

С frame вы также можете использовать диалоговое окно.

0