Exemplo n.º 1
0
  public synchronized void toggleFullScreen() {
    if (inFullScreen) {
      this.dispose();
      gd.setFullScreenWindow(null);
      canvas.setSize(NES_HEIGHT * screenScaleFactor, NES_WIDTH * screenScaleFactor);
      this.setUndecorated(false);
      this.setVisible(true);
      inFullScreen = false;
      buildMenus();
      // nes.resume();
    } else {
      setJMenuBar(null);
      gd = getGraphicsConfiguration().getDevice();
      if (!gd.isFullScreenSupported()) {
        // then fullscreen will give a window the size of the screen instead
        messageBox("Fullscreen is not supported by your OS or version of Java.");
      }
      this.dispose();
      this.setUndecorated(true);

      gd.setFullScreenWindow(this);
      this.setVisible(true);

      inFullScreen = true;
    }
  }
Exemplo n.º 2
0
  public void setFullscreen(boolean fullscreen) {
    // get a reference to the device.
    GraphicsDevice device =
        GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
    DisplayMode dispMode = device.getDisplayMode();
    // save the old display mode before changing it.
    dispModeOld = device.getDisplayMode();

    if (this.fullscreen != fullscreen) { // are we actually changing modes.
      // change modes.
      this.fullscreen = fullscreen;
      // toggle fullscreen mode
      if (!fullscreen) {
        // change to windowed mode.
        // set the display mode back to the what it was when
        // the program was launched.
        device.setDisplayMode(dispModeOld);
        // hide the frame so we can change it.
        setVisible(false);
        // remove the frame from being displayable.
        dispose();
        // put the borders back on the frame.
        setUndecorated(false);
        // needed to unset this window as the fullscreen window.
        device.setFullScreenWindow(null);
        // recenter window
        setLocationRelativeTo(null);
        setResizable(true);

        // reset the display mode to what it was before
        // we changed it.
        setVisible(true);

      } else { // change to fullscreen.
        // hide everything
        setVisible(false);
        // remove the frame from being displayable.
        dispose();
        // remove borders around the frame
        setUndecorated(true);
        // make the window fullscreen.
        device.setFullScreenWindow(this);
        // attempt to change the screen resolution.
        device.setDisplayMode(dispMode);
        setResizable(false);
        setAlwaysOnTop(false);
        // show the frame
        setVisible(true);
      }
      // make sure that the screen is refreshed.
      repaint();
    }
  }
Exemplo n.º 3
0
 /** Recupera el modo de pantalla no completa */
 public void recuperarPantalla() {
   Window window = device.getFullScreenWindow();
   if (window != null) {
     window.dispose();
   }
   device.setFullScreenWindow(null);
 }
Exemplo n.º 4
0
  public PlateauGraphique(/*int largeur, int hauteur,*/ Monopoly m) {

    this.m = m;
    cases = new ArrayList<CaseGraphique>();

    setExtendedState(JFrame.MAXIMIZED_BOTH);
    GraphicsDevice device =
        GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
    device.setFullScreenWindow(this);

    this.largeur = getContentPane().getWidth();
    this.hauteur = getContentPane().getHeight();

    if (largeur > hauteur) largeur = hauteur;
    else hauteur = largeur;

    initialiser();

    addComponents(getContentPane());

    for (Joueur j : m.getJoueurs()) {
      ((JoueurDefaut) j).addObserver(this);
    }

    pack();
    setVisible(true);
  }
Exemplo n.º 5
0
  public MafiaMainClass() {
    setLayout(card); // BorderLayout

    // add("WR",wr);
    add("LOG", login); // window창 위에 penal을 올린다
    setTitle("MAFIA GAME - LOGIN");
    setSize(1280, 985); // window 크기

    /*			// 창을 중앙에 띄운다.
    			Dimension screen=Toolkit.getDefaultToolkit().getScreenSize();
    			Dimension ex_size = this.getSize();

    			int xpos=(int)(screen.getWidth()/2 - this.getWidth()/2);
    			int ypos=(int)(screen.getHeight()/2 - this.getHeight()/2);

    			this.setLocation(xpos,ypos);
    */
    // 전체화면
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice gd = ge.getDefaultScreenDevice();
    setUndecorated(true);
    gd.setFullScreenWindow(this);

    setVisible(true); // window 보이기
    setResizable(false); // 화면크기 고정

    addMouseListener(this); // mouse움직임
  }
Exemplo n.º 6
0
  public void beginExecution() {
    if (cam == null) {

      int numBuffers = 2;

      env = GraphicsEnvironment.getLocalGraphicsEnvironment();
      device = env.getDefaultScreenDevice();
      // MultiBufferTest test = new MultiBufferTest(numBuffers, device);

      try {

        GraphicsConfiguration gc = device.getDefaultConfiguration();
        mainFrame = new Frame(gc);
        mainFrame.setUndecorated(true);
        mainFrame.setIgnoreRepaint(true);
        device.setFullScreenWindow(mainFrame);
        if (device.isDisplayChangeSupported()) {
          chooseBestDisplayMode(device);
        }
        mainFrame.createBufferStrategy(numBuffers);
        bufferStrategy = mainFrame.getBufferStrategy();

      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
Exemplo n.º 7
0
 // get out of full screen
 public void restoreScreen() {
   Window w = vc.getFullScreenWindow();
   if (w != null) {
     w.dispose();
   }
   vc.setFullScreenWindow(null);
 }
Exemplo n.º 8
0
  private boolean enterFullScreenMode() {
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice[] devices = ge.getScreenDevices();
    for (int i = 0; i < devices.length; i++) {
      GraphicsDevice device = devices[i];
      if (device.isFullScreenSupported() && device.getFullScreenWindow() == null) {
        log.info("Switching to full screen mode.");

        frame.setVisible(false);

        try {
          device.setFullScreenWindow(frame);
        } catch (InternalError e) {
          log.error("Failed to switch to full screen exclusive mode.");
          e.printStackTrace();

          frame.setVisible(true);
          return false;
        }

        frame.dispose();
        frame.setUndecorated(true);
        frame.setVisible(true);
        frame.requestFocusInWindow();

        return true;
      }
    }

    log.warn("No screens available or full screen exclusive mode is unsupported on your platform.");

    postError("Full screen mode is not supported on your platform.");

    return false;
  }
 /** Restores the screen's display mode. */
 public void restoreScreen() {
   Window window = device.getFullScreenWindow();
   if (window != null) {
     window.dispose();
   }
   device.setFullScreenWindow(null);
 }
Exemplo n.º 10
0
  /**
   * ZombieFrame's constructor.
   *
   * @param contents Optional JPanel(s) to add to content pane. Arguments > 0 are ignored.
   */
  public ZombieFrame(JPanel... contents) {
    super("ZombieHouse");

    // Request keyboard focus for the frame.
    setFocusable(true);
    requestFocusInWindow();
    requestFocus();

    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setUndecorated(true);
    setResizable(false);
    setBackground(Color.BLACK);

    // The content pane. An optional JPanel may be passed into the
    // constructor. It creates an empty pane with a black background if
    // one isn't provided.
    pane = getContentPane();
    pane.setBackground(Color.BLACK);
    pane.setFocusable(false);
    pane.setVisible(true);
    if (contents.length > 0) {
      pane.add(contents[0]);
    }

    keys = new ZombieKeyBinds((JComponent) pane);

    // Get the graphics device information.
    GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice graphics = environment.getDefaultScreenDevice();

    pack();

    // Go full screen, if supported.
    if (graphics.isFullScreenSupported()) {
      try {
        graphics.setFullScreenWindow(this);
        // Having gone full screen, retrieve the display size.
        // size = Toolkit.getDefaultToolkit().getScreenSize();

        // This double-switching of setVisible is to fix a bug with
        // full-screen-exclusive mode on OS X. Versions 10.8 and later
        // don't send keyboard events properly without it.
        if (System.getProperty("os.name").contains("OS X")) {
          setVisible(false);
        }
      } catch (HeadlessException ex) {
        System.err.println(
            "Error: primary display not set or found. "
                + "Your experience of life may be suboptimal.");
        ex.printStackTrace();
      }
    } else {
      // If full-screen-exclusive mode isn't supported, switch to
      // maximized window mode.
      System.err.println("Full-screen-exclusive mode not supported.");
      setExtendedState(Frame.MAXIMIZED_BOTH);
    }
    setVisible(true);
  }
Exemplo n.º 11
0
  /**
   * Create the window, asking for which screen to use if there are multiple monitors and either
   * forcechoice is true, or the user hasn't already picked a screen.
   *
   * @param part the JComponent to display
   * @param forcechoice false if user shouldn't be asked twice which of several monitors to use.
   */
  private void init(JComponent part, boolean forcechoice) {

    if (forcechoice) {

      defaultScreen = null;
    }

    screen = null;

    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

    GraphicsDevice screens[] = ge.getScreenDevices();

    if (defaultScreen != null) {

      for (int i = 0; i < screens.length; i++) {

        if (screens[i] == defaultScreen) {

          screen = defaultScreen;
        }
      }
    }

    if (screens.length == 1) {

      screen = screens[0];
    }

    if (screen == null) {

      screen = pickScreen(screens);
    }

    if (dead) {

      return;
    }

    defaultScreen = screen;

    DisplayMode dm = screen.getDisplayMode();

    GraphicsConfiguration gc = screen.getDefaultConfiguration();

    jf = new JFrame(gc);

    jf.setUndecorated(true);

    jf.setBounds(gc.getBounds());

    jf.getContentPane().add(part);

    jf.setVisible(true);

    screen.setFullScreenWindow(jf);
  }
Exemplo n.º 12
0
 public void stop() {
   started = false;
   timer.stop();
   setVisible(false);
   stopper.terminate();
   if (terminateOnClose) {
     System.exit(0);
   }
   gd.setFullScreenWindow(null);
 }
Exemplo n.º 13
0
 /**
  * Esta funcion recibe un modo y lo pone si es posible.
  *
  * @param dm Modo nuevo.
  */
 public void cambiarModo(DisplayMode dm) {
   try {
     if (device.isDisplayChangeSupported()) {
       device.setFullScreenWindow(getFullScreenWindow());
       device.setDisplayMode(dm);
     } else System.out.println("No se permite el cambio de resolucion");
   } catch (IllegalArgumentException ex) {
     System.out.println("Error de argumentos... No se ha podido poner a pantalla completa. ");
   }
 }
Exemplo n.º 14
0
 public void start() {
   started = true;
   if (allowAltTab && !debugMode) {
     stopper.start();
   }
   setVisible(true);
   if (SystemUtil.isMac()) {
     gd.setFullScreenWindow(this);
   }
   timer.start();
 }
  /** Enters full screen mode and changes the display mode. */
  public void setFullScreen(DisplayMode displayMode, JFrame window) {

    window.setUndecorated(true);
    window.setResizable(false);
    cmdemo bgd = new cmdemo();
    JList mission = new JList(string);
    mission.setVisibleRowCount(4);
    JScrollPane pane = new JScrollPane(mission);
    pane.setBounds(400, 400, 225, 70);
    window.getContentPane().add(pane);

    muButton.setBounds(764 - 120, 625 - 10, 225, 49);
    textField1.setBounds(630 - 120, 328 - 10, 225, 25);
    window.getContentPane().add(muButton);
    window.getContentPane().add(textField1);
    // window.add(bgd);
    muButton.setDebugGraphicsOptions(javax.swing.DebugGraphics.NONE_OPTION);
    muButton.setToolTipText("start");
    muButton.setBorder(null);
    muButton.setRolloverIcon(new javax.swing.ImageIcon("imgs/start1.jpg"));
    muButton.addActionListener(
        new java.awt.event.ActionListener() {

          public void actionPerformed(java.awt.event.ActionEvent evt) {
            startActionPerformed(evt);
          }
        });

    aButton.setBounds(284 - 120, 625 - 10, 225, 49);
    window.getContentPane().add(aButton);
    window.add(bgd);
    aButton.setDebugGraphicsOptions(javax.swing.DebugGraphics.NONE_OPTION);
    aButton.setToolTipText("back");
    aButton.setBorder(null);
    aButton.setRolloverIcon(new javax.swing.ImageIcon("imgs/back1.jpg"));

    aButton.addActionListener(
        new java.awt.event.ActionListener() {

          public void actionPerformed(java.awt.event.ActionEvent evt) {
            backActionPerformed(evt);
          }
        });

    device.setFullScreenWindow(window);
    if (displayMode != null && device.isDisplayChangeSupported()) {
      try {
        device.setDisplayMode(displayMode);
      } catch (IllegalArgumentException ex) {
        // ignore - illegal mode for this device
      }
    }
  }
Exemplo n.º 16
0
  /**
   * Close the full screen window. This particular FullScreenWindow
   *
   * <p>object cannot be used again.
   */
  public void close() {

    dead = true;

    flag.set();

    screen.setFullScreenWindow(null);

    if (jf != null) {

      jf.dispose();
    }
  }
Exemplo n.º 17
0
 public static void setFullscreen(boolean fs) {
   GraphicsDevice device = guiFrame.getGraphicsConfiguration().getDevice();
   // hide window
   guiFrame.setVisible(false);
   guiFrame.dispose();
   // change options
   guiFrame.setUndecorated(fs);
   device.setFullScreenWindow(fs ? guiFrame : null);
   // display window
   guiFrame.setLocationRelativeTo(null);
   guiFrame.setVisible(true);
   fullscreen = fs;
 }
  private void exitFullscreen() {
    GraphicsDevice device = m_renderTarget.getGraphicsConfiguration().getDevice();

    Window fullscrenWindow = device.getFullScreenWindow();

    if (fullscrenWindow == m_renderTarget) {
      device.setFullScreenWindow(null);
      m_renderTarget.setBounds(
          new Rectangle(
              m_renderTarget.getLocation(),
              new Dimension(m_canvasRenderWidth, m_canvasRenderHeight)));
    }
  }
Exemplo n.º 19
0
  public static void main(String agrs[]) {
    // Determine if full-screen mode is supported directly
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice gs = ge.getDefaultScreenDevice();
    if (gs.isFullScreenSupported()) {
      // Full-screen mode is supported
    } else {
      // Full-screen mode will be simulated
    }

    // Create a button that leaves full-screen mode
    Button btn = new Button("OK");
    btn.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent evt) {
            // Return to normal windowed mode
            GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
            GraphicsDevice gs = ge.getDefaultScreenDevice();
            gs.setFullScreenWindow(null);
          }
        });

    // Create a window for full-screen mode; add a button to leave full-screen mode
    Frame frame = new Frame(gs.getDefaultConfiguration());
    Window win = new Window(frame);
    win.add(btn, BorderLayout.CENTER);

    try {
      // Enter full-screen mode
      gs.setFullScreenWindow(win);
      win.validate();

      // ...
    } finally {
      // Exit full-screen mode
      gs.setFullScreenWindow(null);
    }
  }
Exemplo n.º 20
0
  /** Pasa a modo grafico en pantalla completa. */
  private void initFullScreen(int width, int height, int depth, int refresh) {
    this.width = width;
    this.height = height;
    window.setUndecorated(true);
    window.setIgnoreRepaint(true);
    try {
      graphicsDevice.setFullScreenWindow(window);
      graphicsDevice.setDisplayMode(new DisplayMode(width, height, depth, refresh));
      timer = new N3Timer(1, this);

    } catch (Exception e) {
      shutdown();
    }
  }
Exemplo n.º 21
0
 public void setwnd() {
   GraphicsDevice dev = getGraphicsConfiguration().getDevice();
   if (prefs == null) return;
   try {
     dev.setDisplayMode(prefs);
     dev.setFullScreenWindow(null);
     setVisible(false);
     dispose();
     setUndecorated(false);
     setVisible(true);
   } catch (Exception e) {
     throw (new RuntimeException(e));
   }
   prefs = null;
 }
Exemplo n.º 22
0
  // make frame full screen
  public void setFullScreen(DisplayMode dm) {
    JFrame f = new JFrame();
    f.setUndecorated(true);
    f.setIgnoreRepaint(true);
    f.setResizable(false);
    vc.setFullScreenWindow(f);

    if (dm != null && vc.isDisplayChangeSupported()) {
      try {
        vc.setDisplayMode(dm);
      } catch (Exception ex) {
      }
    }
    f.createBufferStrategy(2);
  }
Exemplo n.º 23
0
 public MultiBufferTest(int numBuffers, GraphicsDevice device) {
   try {
     GraphicsConfiguration gc = device.getDefaultConfiguration();
     mainFrame = new Frame(gc);
     mainFrame.setUndecorated(true);
     mainFrame.setIgnoreRepaint(true);
     device.setFullScreenWindow(mainFrame);
     //            if (device.isDisplayChangeSupported()) {
     //                chooseBestDisplayMode(device);
     //            }
     Rectangle bounds = mainFrame.getBounds();
     mainFrame.createBufferStrategy(numBuffers);
     BufferStrategy bufferStrategy = mainFrame.getBufferStrategy();
     for (float lag = 2000.0f; lag > 0.00000006f; lag = lag / 1.33f) {
       System.out.println("lag = " + lag);
       for (int i = 0; i < numBuffers; i++) {
         Graphics g = bufferStrategy.getDrawGraphics();
         if (!bufferStrategy.contentsLost()) {
           g.setColor(COLORS[i]);
           //                        g.fillRect(0,0,bounds.width, bounds.height);
           g.fillRect(0, 0, 20, 20);
           bufferStrategy.show();
           g.dispose();
         }
         try {
           Thread.sleep((int) lag);
         } catch (InterruptedException e) {
         }
       }
     }
   } catch (Exception e) {
     logger.error(e.getMessage(), e);
   } finally {
     device.setFullScreenWindow(null);
   }
 }
Exemplo n.º 24
0
 public void setfs() {
   GraphicsDevice dev = getGraphicsConfiguration().getDevice();
   if (prefs != null) return;
   prefs = dev.getDisplayMode();
   try {
     setVisible(false);
     dispose();
     setUndecorated(true);
     setVisible(true);
     dev.setFullScreenWindow(this);
     dev.setDisplayMode(fsmode);
     pack();
   } catch (Exception e) {
     throw (new RuntimeException(e));
   }
 }
Exemplo n.º 25
0
 private static void setFullscreen(boolean fs) {
   if (fs != fullscreen) {
     GraphicsDevice device = guiFrame.getGraphicsConfiguration().getDevice();
     // hide window
     guiFrame.setVisible(false);
     guiFrame.dispose();
     // change options
     guiFrame.setUndecorated(fs);
     device.setFullScreenWindow(fs ? guiFrame : null);
     // display window
     guiFrame.setLocationRelativeTo(null);
     guiFrame.setVisible(true);
     instance.requestFocusInWindow();
     fullscreen = fs;
   }
   Options.set(Options.FULLSCREEN, fullscreen);
 }
Exemplo n.º 26
0
  /** @param args */
  public static void main(String[] args) {
    // Make instance of this class, acts as parent for frames
    Init init = new Init();

    // get the graphics environment
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice[] gs = ge.getScreenDevices();
    // check there are more than one devices
    // this is actually broken (has 2 devices whether or not projector is connected)
    // odd
    if (gs.length < 1) {
      System.err.println("You haven't connected the projector!");
      System.exit(1);
    }
    // get the projector and screen
    GraphicsDevice gd0 = gs[1]; // projector
    GraphicsDevice gd1 = gs[0]; // screen
    GraphicsConfiguration gc = gd0.getDefaultConfiguration();
    // set projection's graphics configuration to device 0 (projector)
    init.m_projection = new Projection(gc);
    // create the gui frame on device 1 (screen)
    init.m_gui = new GUI(init, gd1.getDefaultConfiguration());

    // set size of control box
    init.m_gui.setSize(CONTROL_WIDTH, CONTROL_HEIGHT);

    // make projection fullscreen
    gd0.setFullScreenWindow(init.m_projection);

    // close everything on any frame's closing
    init.m_gui.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    init.m_projection.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    // show frames
    init.m_gui.setVisible(true);
    init.m_projection.setVisible(true);

    // Create chess interface
    init.m_chess = new ChessInit();

    // Make webcam
    init.m_camera = new Camera(init);
    // Start camera going
    init.m_camera.init();
  }
Exemplo n.º 27
0
  private void leaveFullScreenMode() {
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice[] devices = ge.getScreenDevices();
    for (int i = 0; i < devices.length; i++) {
      GraphicsDevice device = devices[i];
      if (device.isFullScreenSupported() && device.getFullScreenWindow() == frame) {
        log.info("Leaving full screen mode.");

        frame.setVisible(false);
        device.setFullScreenWindow(null);
        frame.dispose();
        frame.setUndecorated(false);
        frame.setVisible(true);

        break;
      }
    }
  }
Exemplo n.º 28
0
  public FullScreenFrame(final NodeBoxDocument document) {
    this.document = document;
    setLayout(new BorderLayout(0, 0));

    viewer = new Viewer();
    document.addZoomListener(viewer);
    add(viewer, BorderLayout.CENTER);

    GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();

    if (gd.isFullScreenSupported()) {
      setUndecorated(true);
      gd.setFullScreenWindow(this);
    } else {
      System.err.println("Full screen not supported");
      setSize(100, 100); // just something to let you see the window
      setVisible(true);
    }
  }
Exemplo n.º 29
0
 public static void main(String[] args) {
   if (GraphicsEnvironment.isHeadless()) {
     System.out.println("no screen detected");
     return;
   } else {
     // <begin>
     IFacade facade = new asteroids.Facade();
     // <end>
     GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
     GraphicsDevice device = env.getDefaultScreenDevice();
     Asteroids asteroids;
     if (device.isFullScreenSupported()) {
       asteroids = new Asteroids(facade, true);
       device.setFullScreenWindow(asteroids);
     } else {
       asteroids = new Asteroids(facade, false);
     }
     asteroids.start();
   }
 }
  private void enterFullscreen() {
    GraphicsDevice device = m_renderTarget.getGraphicsConfiguration().getDevice();

    if (!device.isFullScreenSupported())
      m_logger.error("Cannot enter full-screen. Device does not support full-screen mode");
    else {
      device.setFullScreenWindow(m_renderTarget);

      DisplayMode best = device.getDisplayMode();

      if (!device.isDisplayChangeSupported())
        m_logger.error(
            "Device does not support change of display modes. Using default display mode.");
      else {
        for (DisplayMode d : device.getDisplayModes()) {
          int dDeltaWidth = d.getWidth() - m_canvasRenderWidth;
          int dDeltaHeight = d.getHeight() - m_canvasRenderHeight;
          int dDeltaBitDepth = d.getBitDepth() - PREFERRED_BIT_DEPTH;

          int bestDeltaWidth = best.getWidth() - m_canvasRenderWidth;
          int bestDeltaHeight = best.getHeight() - m_canvasRenderHeight;
          int bestDeltaBitDepth = best.getBitDepth() - PREFERRED_BIT_DEPTH;

          if (dDeltaWidth == bestDeltaWidth && dDeltaHeight == bestDeltaHeight) {
            if (d.getBitDepth() > MIN_BIT_DEPTH
                && (Math.abs(dDeltaBitDepth) < Math.abs(bestDeltaBitDepth))) best = d;
          } else if (dDeltaWidth == 0
              || (dDeltaWidth > 0 && dDeltaWidth < bestDeltaWidth) && dDeltaHeight == 0
              || (dDeltaHeight > 0 && dDeltaHeight < bestDeltaWidth)) {
            best = d;
          }
        }
        device.setDisplayMode(best);
      }

      m_renderTarget.setBounds(
          new Rectangle(
              m_renderTarget.getLocation(), new Dimension(best.getWidth(), best.getHeight())));
    }
  }