Пример #1
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();
   }
 }
Пример #2
0
  public void start() {
    Toolkit.getDefaultToolkit()
        .addAWTEventListener(
            new AWTEventListener() {
              public void eventDispatched(AWTEvent e) {
                System.out.println(e.toString());
              }
            },
            FocusEvent.FOCUS_EVENT_MASK
                | WindowEvent.WINDOW_FOCUS_EVENT_MASK
                | WindowEvent.WINDOW_EVENT_MASK);

    frame = new Frame("Frame");
    frame.setName("Frame-owner");
    frame.setBounds(100, 0, 100, 100);
    dialog = new Dialog(frame, "Dialog");
    dialog.setName("Dialog-owner");
    dialog.setBounds(100, 0, 100, 100);

    window1 = new Window(frame);
    window1.setName("1st child");
    window1.setBounds(100, 300, 100, 100);
    window2 = new Window(window1);
    window2.setName("2nd child");
    window2.setBounds(100, 500, 100, 100);

    test1(frame, window1);
    test2(frame, window1, window2);
    test3(frame, window1, window2);

    window1 = new Window(dialog);
    window1.setBounds(100, 300, 100, 100);
    window1.setName("1st child");
    window2 = new Window(window1);
    window2.setName("2nd child");
    window2.setBounds(100, 500, 100, 100);

    test1(dialog, window1);
    test2(dialog, window1, window2);
    test3(dialog, window1, window2);

    System.out.println("Test passed.");
  }
Пример #3
0
 /*
 	This could live in the desktop script.
 	However we'd like to get it on the screen as quickly as possible.
 */
 public static void startSplashScreen() {
   int width = 275, height = 148;
   Window win = new Window(new Frame());
   win.pack();
   BshCanvas can = new BshCanvas();
   can.setSize(width, height); // why is this necessary?
   Toolkit tk = Toolkit.getDefaultToolkit();
   Dimension dim = tk.getScreenSize();
   win.setBounds(dim.width / 2 - width / 2, dim.height / 2 - height / 2, width, height);
   win.add("Center", can);
   Image img = tk.getImage(Interpreter.class.getResource("/bsh/util/lib/splash.gif"));
   MediaTracker mt = new MediaTracker(can);
   mt.addImage(img, 0);
   try {
     mt.waitForAll();
   } catch (Exception e) {
   }
   Graphics gr = can.getBufferedGraphics();
   gr.drawImage(img, 0, 0, can);
   win.setVisible(true);
   win.toFront();
   splashScreen = win;
 }
Пример #4
0
    public void mouseDragged(MouseEvent ev) {
      Window w = (Window) ev.getSource();
      Point pt = ev.getPoint();

      if (isMovingWindow) {
        Point windowPt;
        try {
          windowPt = (Point) AccessController.doPrivileged(getLocationAction);
          windowPt.x = windowPt.x - dragOffsetX;
          windowPt.y = windowPt.y - dragOffsetY;
          w.setLocation(windowPt);
        } catch (PrivilegedActionException e) {
        }
      } else if (dragCursor != 0) {
        Rectangle r = w.getBounds();
        Rectangle startBounds = new Rectangle(r);
        Dimension min = w.getMinimumSize();

        switch (dragCursor) {
          case Cursor.E_RESIZE_CURSOR:
            adjust(r, min, 0, 0, pt.x + (dragWidth - dragOffsetX) - r.width, 0);
            break;
          case Cursor.S_RESIZE_CURSOR:
            adjust(r, min, 0, 0, 0, pt.y + (dragHeight - dragOffsetY) - r.height);
            break;
          case Cursor.N_RESIZE_CURSOR:
            adjust(r, min, 0, pt.y - dragOffsetY, 0, -(pt.y - dragOffsetY));
            break;
          case Cursor.W_RESIZE_CURSOR:
            adjust(r, min, pt.x - dragOffsetX, 0, -(pt.x - dragOffsetX), 0);
            break;
          case Cursor.NE_RESIZE_CURSOR:
            adjust(
                r,
                min,
                0,
                pt.y - dragOffsetY,
                pt.x + (dragWidth - dragOffsetX) - r.width,
                -(pt.y - dragOffsetY));
            break;
          case Cursor.SE_RESIZE_CURSOR:
            adjust(
                r,
                min,
                0,
                0,
                pt.x + (dragWidth - dragOffsetX) - r.width,
                pt.y + (dragHeight - dragOffsetY) - r.height);
            break;
          case Cursor.NW_RESIZE_CURSOR:
            adjust(
                r,
                min,
                pt.x - dragOffsetX,
                pt.y - dragOffsetY,
                -(pt.x - dragOffsetX),
                -(pt.y - dragOffsetY));
            break;
          case Cursor.SW_RESIZE_CURSOR:
            adjust(
                r,
                min,
                pt.x - dragOffsetX,
                0,
                -(pt.x - dragOffsetX),
                pt.y + (dragHeight - dragOffsetY) - r.height);
            break;
          default:
            break;
        }
        if (!r.equals(startBounds)) {
          w.setBounds(r);
          // Defer repaint/validate on mouseReleased unless dynamic
          // layout is active.
          if (Toolkit.getDefaultToolkit().isDynamicLayoutActive()) {
            w.validate();
            getRootPane().repaint();
          }
        }
      }
    }