private static void setDisplayModeAndFullscreenInternal(boolean fullscreen, DisplayMode mode)
     throws LWJGLException {
   synchronized (GlobalLock.lock) {
     if (mode == null) throw new NullPointerException("mode must be non-null");
     DisplayMode old_mode = current_mode;
     current_mode = mode;
     boolean was_fullscreen = isFullscreen();
     Display.fullscreen = fullscreen;
     if (was_fullscreen != isFullscreen() || !mode.equals(old_mode)) {
       if (!isCreated()) return;
       destroyWindow();
       try {
         if (isFullscreen()) {
           switchDisplayMode();
         } else {
           display_impl.resetDisplayMode();
         }
         createWindow();
         makeCurrentAndSetSwapInterval();
       } catch (LWJGLException e) {
         drawable.destroy();
         display_impl.resetDisplayMode();
         throw e;
       }
     }
   }
 }
  /**
   * Swap the display buffers. This method is called from update(), and should normally not be
   * called by the application.
   *
   * @throws OpenGLException if an OpenGL error has occured since the last call to glGetError()
   */
  public static void swapBuffers() throws LWJGLException {
    synchronized (GlobalLock.lock) {
      if (!isCreated()) throw new IllegalStateException("Display not created");

      if (LWJGLUtil.DEBUG) drawable.checkGLError();
      drawable.swapBuffers();
    }
  }
 private static void makeCurrentAndSetSwapInterval() throws LWJGLException {
   makeCurrent();
   try {
     drawable.checkGLError();
   } catch (OpenGLException e) {
     LWJGLUtil.log("OpenGL error during context creation: " + e.getMessage());
   }
   setSwapInterval(swap_interval);
 }
 private static void releaseDrawable() {
   try {
     Context context = drawable.getContext();
     if (context != null && context.isCurrent()) {
       context.releaseCurrent();
       context.releaseDrawable();
     }
   } catch (LWJGLException e) {
     LWJGLUtil.log("Exception occurred while trying to release context: " + e);
   }
 }
 /**
  * Set the current display mode. If no OpenGL context has been created, the given mode will apply
  * to the context when create() is called, and no immediate mode switching will happen. If there
  * is a context already, it will be resized according to the given mode. If the context is also a
  * fullscreen context, the mode will also be switched immediately. The native cursor position is
  * also reset.
  *
  * @param mode The new display mode to set
  * @throws LWJGLException if the display mode could not be set
  */
 public static void setDisplayMode(DisplayMode mode) throws LWJGLException {
   synchronized (GlobalLock.lock) {
     if (mode == null) throw new NullPointerException("mode must be non-null");
     boolean was_fullscreen = isFullscreen();
     current_mode = mode;
     if (isCreated()) {
       destroyWindow();
       // If mode is not fullscreen capable, make sure we are in windowed mode
       try {
         if (was_fullscreen && !isFullscreen()) display_impl.resetDisplayMode();
         else if (isFullscreen()) switchDisplayMode();
         createWindow();
         makeCurrentAndSetSwapInterval();
       } catch (LWJGLException e) {
         drawable.destroy();
         display_impl.resetDisplayMode();
         throw e;
       }
     }
   }
 }
 /**
  * Set the parent of the Display. If parent is null, the Display will appear as a top level
  * window. If parent is not null, the Display is made a child of the parent. A parent's
  * isDisplayable() must be true when setParent() is called and remain true until setParent() is
  * called again with null or a different parent. This generally means that the parent component
  * must remain added to it's parent container.
  *
  * <p>It is not advisable to call this method from an AWT thread, since the context will be made
  * current on the thread and it is difficult to predict which AWT thread will process any given
  * AWT event.
  *
  * <p>While the Display is in fullscreen mode, the current parent will be ignored. Additionally,
  * when a non null parent is specified, the Dispaly will inherit the size of the parent,
  * disregarding the currently set display mode.
  *
  * <p>
  */
 public static void setParent(Canvas parent) throws LWJGLException {
   synchronized (GlobalLock.lock) {
     if (Display.parent != parent) {
       Display.parent = parent;
       if (!isCreated()) return;
       destroyWindow();
       try {
         if (isFullscreen()) {
           switchDisplayMode();
         } else {
           display_impl.resetDisplayMode();
         }
         createWindow();
         makeCurrentAndSetSwapInterval();
       } catch (LWJGLException e) {
         drawable.destroy();
         display_impl.resetDisplayMode();
         throw e;
       }
     }
   }
 }
 /**
  * Make the Display the current rendering context for GL calls.
  *
  * @throws LWJGLException If the context could not be made current
  */
 public static void makeCurrent() throws LWJGLException {
   drawable.makeCurrent();
 }
 /** Returns true if the Display's context is current in the current thread. */
 public static boolean isCurrent() throws LWJGLException {
   return drawable.isCurrent();
 }
 /**
  * Release the Display context.
  *
  * @throws LWJGLException If the context could not be released
  */
 public static void releaseContext() throws LWJGLException {
   drawable.releaseContext();
 }
 /**
  * Set the buffer swap interval. This call is a best-attempt at changing the monitor swap
  * interval, which is the minimum periodicity of color buffer swaps, measured in video frame
  * periods, and is not guaranteed to be successful.
  *
  * <p>A video frame period is the time required to display a full frame of video data.
  *
  * @param value The swap interval in frames, 0 to disable
  */
 public static void setSwapInterval(int value) {
   synchronized (GlobalLock.lock) {
     swap_interval = value;
     if (isCreated()) drawable.setSwapInterval(swap_interval);
   }
 }
 /**
  * Destroy the Display. After this call, there will be no current GL rendering context, regardless
  * of whether the Display was the current rendering context.
  */
 public static void destroy() {
   if (isCreated()) {
     drawable.destroy();
   }
 }
 private static void initContext() {
   drawable.initContext(r, g, b);
   update();
 }
Example #13
0
  public void createWindow(DrawableLWJGL drawable, DisplayMode mode, Canvas parent, int x, int y)
      throws LWJGLException {
    close_requested = false;
    is_dirty = false;
    isMinimized = false;
    isFocused = false;
    redoMakeContextCurrent = false;
    maximized = false;
    this.parent = parent;
    hasParent = parent != null;
    parent_hwnd = parent != null ? getHwnd(parent) : 0;
    this.hwnd =
        nCreateWindow(
            x,
            y,
            mode.getWidth(),
            mode.getHeight(),
            Display.isFullscreen() || isUndecorated(),
            parent != null,
            parent_hwnd);
    this.resizable = false;
    if (hwnd == 0) {
      throw new LWJGLException("Failed to create window");
    }
    this.hdc = getDC(hwnd);
    if (hdc == 0) {
      nDestroyWindow(hwnd);
      throw new LWJGLException("Failed to get dc");
    }

    try {
      if (drawable instanceof DrawableGL) {
        int format =
            WindowsPeerInfo.choosePixelFormat(
                getHdc(),
                0,
                0,
                (PixelFormat) drawable.getPixelFormat(),
                null,
                true,
                true,
                false,
                true);
        WindowsPeerInfo.setPixelFormat(getHdc(), format);
      } else {
        peer_info = new WindowsDisplayPeerInfo(true);
        ((DrawableGLES) drawable)
            .initialize(
                hwnd,
                hdc,
                EGL.EGL_WINDOW_BIT,
                (org.lwjgl.opengles.PixelFormat) drawable.getPixelFormat());
      }
      peer_info.initDC(getHwnd(), getHdc());
      showWindow(getHwnd(), SW_SHOWDEFAULT);

      updateWidthAndHeight();

      if (parent == null) {
        if (Display.isResizable()) {
          setResizable(true);
        }
        setForegroundWindow(getHwnd());
      } else {
        parent_focused = new AtomicBoolean(false);
        parent.addFocusListener(
            parent_focus_tracker =
                new FocusAdapter() {
                  public void focusGained(FocusEvent e) {
                    parent_focused.set(true);
                    clearAWTFocus();
                  }
                });
        SwingUtilities.invokeLater(
            new Runnable() {
              public void run() {
                clearAWTFocus();
              }
            });
      }
      grabFocus();
    } catch (LWJGLException e) {
      nReleaseDC(hwnd, hdc);
      nDestroyWindow(hwnd);
      throw e;
    }
  }