Exemplo n.º 1
0
  /** Returns the popup type to use for the specified parameters. */
  private int getPopupType(Component owner, Component contents, int ownerX, int ownerY) {
    int popupType = getPopupType();

    if (owner == null || invokerInHeavyWeightPopup(owner)) {
      popupType = HEAVY_WEIGHT_POPUP;
    } else if (popupType == LIGHT_WEIGHT_POPUP
        && !(contents instanceof JToolTip)
        && !(contents instanceof JPopupMenu)) {
      popupType = MEDIUM_WEIGHT_POPUP;
    }

    // Check if the parent component is an option pane.  If so we need to
    // force a heavy weight popup in order to have event dispatching work
    // correctly.
    Component c = owner;
    while (c != null) {
      if (c instanceof JComponent) {
        if (((JComponent) c).getClientProperty(PopupFactory_FORCE_HEAVYWEIGHT_POPUP)
            == Boolean.TRUE) {
          popupType = HEAVY_WEIGHT_POPUP;
          break;
        }
      } else if (c instanceof Window) {
        Window w = (Window) c;
        if (!w.isOpaque() || w.getOpacity() < 1 || w.getShape() != null) {
          popupType = HEAVY_WEIGHT_POPUP;
          break;
        }
      }
      c = c.getParent();
    }

    return popupType;
  }
Exemplo n.º 2
0
 /**
  * Enter full-screen mode, or return to windowed mode. The entered full-screen mode may be either
  * exclusive or simulated. Exclusive mode is only available if <code>isFullScreenSupported</code>
  * returns <code>true</code>.
  *
  * <p>Exclusive mode implies:
  *
  * <ul>
  *   <li>Windows cannot overlap the full-screen window. All other application windows will always
  *       appear beneath the full-screen window in the Z-order.
  *   <li>There can be only one full-screen window on a device at any time, so calling this method
  *       while there is an existing full-screen Window will cause the existing full-screen window
  *       to return to windowed mode.
  *   <li>Input method windows are disabled. It is advisable to call <code>
  *       Component.enableInputMethods(false)</code> to make a component a non-client of the input
  *       method framework.
  * </ul>
  *
  * <p>Simulated full-screen mode resizes the window to the size of the screen and positions it at
  * (0,0).
  *
  * <p>When entering full-screen mode, if the window to be used as a full-screen window is not
  * visible, this method will make it visible. It will remain visible when returning to windowed
  * mode.
  *
  * <p>When entering full-screen mode, all the translucency effects are reset for the window. Its
  * shape is set to {@code null}, the opacity value is set to 1.0f, and the background color alpha
  * is set to 255 (completely opaque). These values are not restored when returning to windowed
  * mode.
  *
  * <p>When returning to windowed mode from an exclusive full-screen window, any display changes
  * made by calling {@code setDisplayMode} are automatically restored to their original state.
  *
  * @param w a window to use as the full-screen window; {@code null} if returning to windowed mode.
  *     Some platforms expect the fullscreen window to be a top-level component (i.e., a {@code
  *     Frame}); therefore it is preferable to use a {@code Frame} here rather than a {@code
  *     Window}.
  * @see #isFullScreenSupported
  * @see #getFullScreenWindow
  * @see #setDisplayMode
  * @see Component#enableInputMethods
  * @see Component#setVisible
  * @since 1.4
  */
 public void setFullScreenWindow(Window w) {
   if (w != null) {
     if (w.getShape() != null) {
       w.setShape(null);
     }
     if (w.getOpacity() < 1.0f) {
       w.setOpacity(1.0f);
     }
     if (!w.isOpaque()) {
       Color bgColor = w.getBackground();
       bgColor = new Color(bgColor.getRed(), bgColor.getGreen(), bgColor.getBlue(), 255);
       w.setBackground(bgColor);
     }
   }
   if (fullScreenWindow != null && windowedModeBounds != null) {
     // if the window went into fs mode before it was realized it may
     // have (0,0) dimensions
     if (windowedModeBounds.width == 0) windowedModeBounds.width = 1;
     if (windowedModeBounds.height == 0) windowedModeBounds.height = 1;
     fullScreenWindow.setBounds(windowedModeBounds);
   }
   // Set the full screen window
   synchronized (fsAppContextLock) {
     // Associate fullscreen window with current AppContext
     if (w == null) {
       fullScreenAppContext = null;
     } else {
       fullScreenAppContext = AppContext.getAppContext();
     }
     fullScreenWindow = w;
   }
   if (fullScreenWindow != null) {
     windowedModeBounds = fullScreenWindow.getBounds();
     // Note that we use the graphics configuration of the device,
     // not the window's, because we're setting the fs window for
     // this device.
     Rectangle screenBounds = getDefaultConfiguration().getBounds();
     fullScreenWindow.setBounds(
         screenBounds.x, screenBounds.y,
         screenBounds.width, screenBounds.height);
     fullScreenWindow.setVisible(true);
     fullScreenWindow.toFront();
   }
 }