Java Frame.MAXIMIZED_BOTH属性代码示例

static void packIfNotMaximized(Window window) {
	// window peut être null lors de l'initialisation
	if (window instanceof Frame
			&& (((Frame) window).getExtendedState() & Frame.MAXIMIZED_BOTH) == 0) {
		window.pack();
	}
}
 

/**
 * Check if state is supported.
 * Note that a compound state is always reported as not supported.
 * Note also that MAXIMIZED_BOTH is considered not a compound state.
 * Therefore, a compound state is just ICONIFIED | anything else.
 *
 */
boolean supportsExtendedState(int state) {
    switch (state) {
      case Frame.MAXIMIZED_VERT:
      case Frame.MAXIMIZED_HORIZ:
          /*
           * WMs that talk NET/WIN protocol, but do not support
           * unidirectional maximization.
           */
          if (getWMID() == METACITY_WM) {
              /* "This is a deliberate policy decision." -hp */
              return false;
          }
          /* FALLTROUGH */
      case Frame.MAXIMIZED_BOTH:
          for (XStateProtocol proto : getProtocols(XStateProtocol.class)) {
              if (proto.supportsState(state)) {
                  return true;
              }
          }
      default:
          return false;
    }
}
 

/**
 * Check if state is supported.
 * Note that a compound state is always reported as not supported.
 * Note also that MAXIMIZED_BOTH is considered not a compound state.
 * Therefore, a compound state is just ICONIFIED | anything else.
 *
 */
@SuppressWarnings("fallthrough")
boolean supportsExtendedState(int state) {
    switch (state) {
      case Frame.MAXIMIZED_VERT:
      case Frame.MAXIMIZED_HORIZ:
          /*
           * WMs that talk NET/WIN protocol, but do not support
           * unidirectional maximization.
           */
          if (getWMID() == METACITY_WM) {
              /* "This is a deliberate policy decision." -hp */
              return false;
          }
          /* FALLTROUGH */
      case Frame.MAXIMIZED_BOTH:
          for (XStateProtocol proto : getProtocols(XStateProtocol.class)) {
              if (proto.supportsState(state)) {
                  return true;
              }
          }
          /* FALLTROUGH */
      default:
          return false;
    }
}
 

/**
 * This method sets back the focus to this JFrame.
 */
public void restoreFocus() {
	if (this.getExtendedState() == Frame.ICONIFIED || this.getExtendedState() == Frame.ICONIFIED + Frame.MAXIMIZED_BOTH) {
		this.setState(Frame.NORMAL);
	}
	this.setAlwaysOnTop(true);
	this.setAlwaysOnTop(false);
}
 

public void componentResized(ComponentEvent e) {
  if (theFrame.isShowing()) {
    // A resize when the window is already maximised only happens when
    // a window is first resized. Record the pre-maximised bounds.
    if (theFrame instanceof Frame &&
        previousBounds != null &&
        ((((Frame) theFrame).getExtendedState() & Frame.MAXIMIZED_BOTH) == Frame.MAXIMIZED_BOTH)) {
      bounds.setBounds(previousBounds);
    }
    else {
      bounds.setSize(theFrame.getSize());
    }
  }
}
 

public void setVisible(boolean vis) {
    if (vis) {
        setupState(false);
    } else {
        if ((state & Frame.MAXIMIZED_BOTH) != 0) {
            XWM.getWM().setExtendedState(this, state & ~Frame.MAXIMIZED_BOTH);
        }
    }
    super.setVisible(vis);
    if (vis && maxBounds != null) {
        setMaximizedBounds(maxBounds);
    }
}
 

@Override final public void componentResized(ComponentEvent objPcomponentEvent) {
	if (this.getExtendedState() == Frame.MAXIMIZED_BOTH) {
		// this.setExtendedState(Frame.NORMAL);
		this.setSize(this.getWidth(), this.intGframeHeight);
	} else {
		this.intGframeHeight = this.getHeight();
	}
	if (this.objGwindowAdjustmentJToggleButton.isSelected()) {
		// this.objGanimationJTable.setWindowAdjustedColumnsWidths(this.objGanimationJScrollPane.getViewport().getWidth());
		// this.objGhandsAndBallsJTable.setWindowAdjustedColumnsWidths(this.objGhandsAndBallsJScrollPane.getViewport().getWidth());
		new Thread(this.objGanimationJTable.objGcolumnFitAdapter).start();
		new Thread(this.objGhandsAndBallsJTable.objGcolumnFitAdapter).start();
	}
}
 

static void testFrame(boolean isUndecorated) throws Exception {
    Frame frame = new Frame();
    try {
        Robot robot = new Robot();
        robot.setAutoDelay(100);

        frame.setUndecorated(isUndecorated);
        GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment()
                .getDefaultScreenDevice().getDefaultConfiguration();
        Rectangle bounds = gc.getBounds();
        Insets insets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
        int x = bounds.x + insets.left;
        int y = bounds.y + insets.top;
        int width = bounds.width - insets.left - insets.right;
        int height = bounds.height - insets.top - insets.bottom;
        Rectangle rect = new Rectangle(x, y, width, height);
        frame.pack();
        frame.setBounds(rect);
        frame.setVisible(true);
        robot.waitForIdle();
        robot.delay(500);

        if (frame.getWidth() <= width / 2
                || frame.getHeight() <= height / 2) {
            throw new RuntimeException("Frame size is small!");
        }

        if (!isUndecorated && frame.getExtendedState() != Frame.MAXIMIZED_BOTH) {
            throw new RuntimeException("Frame state does not equal"
                    + " MAXIMIZED_BOTH!");
        }
    } finally {
        frame.dispose();
    }
}
 

private static boolean isFrameMaximized(JFrame frame) {
    return frame.getExtendedState() == Frame.MAXIMIZED_BOTH;
}
 

private void requestState(XWindowPeer window, int state) {
    /*
     * We have to use toggle for maximization because of transitions
     * from maximization in one direction only to maximization in the
     * other direction only.
     */
    int old_net_state = getState(window);
    int max_changed = (state ^ old_net_state) & (Frame.MAXIMIZED_BOTH);

    XClientMessageEvent req = new XClientMessageEvent();
    try {
        switch(max_changed) {
          case 0:
              return;
          case Frame.MAXIMIZED_HORIZ:
              req.set_data(1, XA_NET_WM_STATE_MAXIMIZED_HORZ.getAtom());
              req.set_data(2, 0);
              break;
          case Frame.MAXIMIZED_VERT:
              req.set_data(1, XA_NET_WM_STATE_MAXIMIZED_VERT.getAtom());
              req.set_data(2, 0);
              break;
          case Frame.MAXIMIZED_BOTH:
              req.set_data(1, XA_NET_WM_STATE_MAXIMIZED_HORZ.getAtom());
              req.set_data(2, XA_NET_WM_STATE_MAXIMIZED_VERT.getAtom());
              break;
          default:
              return;
        }
        if (log.isLoggable(PlatformLogger.Level.FINE)) {
            log.fine("Requesting state on " + window + " for " + state);
        }
        req.set_type((int)XConstants.ClientMessage);
        req.set_window(window.getWindow());
        req.set_message_type(XA_NET_WM_STATE.getAtom());
        req.set_format(32);
        req.set_data(0, _NET_WM_STATE_TOGGLE);
        XToolkit.awtLock();
        try {
            XlibWrapper.XSendEvent(XToolkit.getDisplay(),
                    XlibWrapper.RootWindow(XToolkit.getDisplay(), window.getScreenNumber()),
                    false,
                    XConstants.SubstructureRedirectMask | XConstants.SubstructureNotifyMask,
                    req.pData);
        }
        finally {
            XToolkit.awtUnlock();
        }
    } finally {
        req.dispose();
    }
}
 

private void requestState(XWindowPeer window, int state) {
    /*
     * We have to use toggle for maximization because of transitions
     * from maximization in one direction only to maximization in the
     * other direction only.
     */
    int old_net_state = getState(window);
    int max_changed = (state ^ old_net_state) & (Frame.MAXIMIZED_BOTH);

    XClientMessageEvent req = new XClientMessageEvent();
    try {
        switch(max_changed) {
          case 0:
              return;
          case Frame.MAXIMIZED_HORIZ:
              req.set_data(1, XA_NET_WM_STATE_MAXIMIZED_HORZ.getAtom());
              req.set_data(2, 0);
              break;
          case Frame.MAXIMIZED_VERT:
              req.set_data(1, XA_NET_WM_STATE_MAXIMIZED_VERT.getAtom());
              req.set_data(2, 0);
              break;
          case Frame.MAXIMIZED_BOTH:
              req.set_data(1, XA_NET_WM_STATE_MAXIMIZED_HORZ.getAtom());
              req.set_data(2, XA_NET_WM_STATE_MAXIMIZED_VERT.getAtom());
              break;
          default:
              return;
        }
        if (log.isLoggable(PlatformLogger.Level.FINE)) {
            log.fine("Requesting state on " + window + " for " + state);
        }
        req.set_type(XConstants.ClientMessage);
        req.set_window(window.getWindow());
        req.set_message_type(XA_NET_WM_STATE.getAtom());
        req.set_format(32);
        req.set_data(0, _NET_WM_STATE_TOGGLE);
        XToolkit.awtLock();
        try {
            XlibWrapper.XSendEvent(XToolkit.getDisplay(),
                    XlibWrapper.RootWindow(XToolkit.getDisplay(), window.getScreenNumber()),
                    false,
                    XConstants.SubstructureRedirectMask | XConstants.SubstructureNotifyMask,
                    req.pData);
        }
        finally {
            XToolkit.awtUnlock();
        }
    } finally {
        req.dispose();
    }
}