Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.desktop.jmod - Desktop Module
JDK 11 java.desktop.jmod is the JMOD file for JDK 11 Desktop module.
JDK 11 Desktop module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.desktop.jmod.
JDK 11 Desktop module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Desktop module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.desktop.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/awt/image/BufferStrategy.java
/* * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.awt.image; import java.awt.BufferCapabilities; import java.awt.Graphics; import java.awt.Image; /** * The {@code BufferStrategy} class represents the mechanism with which * to organize complex memory on a particular {@code Canvas} or * {@code Window}. Hardware and software limitations determine whether and * how a particular buffer strategy can be implemented. These limitations * are detectable through the capabilities of the * {@code GraphicsConfiguration} used when creating the * {@code Canvas} or {@code Window}. * <p> * It is worth noting that the terms <i>buffer</i> and <i>surface</i> are meant * to be synonymous: an area of contiguous memory, either in video device * memory or in system memory. * <p> * There are several types of complex buffer strategies, including * sequential ring buffering and blit buffering. * Sequential ring buffering (i.e., double or triple * buffering) is the most common; an application draws to a single <i>back * buffer</i> and then moves the contents to the front (display) in a single * step, either by copying the data or moving the video pointer. * Moving the video pointer exchanges the buffers so that the first buffer * drawn becomes the <i>front buffer</i>, or what is currently displayed on the * device; this is called <i>page flipping</i>. * <p> * Alternatively, the contents of the back buffer can be copied, or * <i>blitted</i> forward in a chain instead of moving the video pointer. * <pre>{@code * Double buffering: * * *********** *********** * * * ------> * * * [To display] <---- * Front B * Show * Back B. * <---- Rendering * * * <------ * * * *********** *********** * * Triple buffering: * * [To *********** *********** *********** * display] * * --------+---------+------> * * * <---- * Front B * Show * Mid. B. * * Back B. * <---- Rendering * * * <------ * * <----- * * * *********** *********** *********** * * }</pre> * <p> * Here is an example of how buffer strategies can be created and used: * <pre><code> * * // Check the capabilities of the GraphicsConfiguration * ... * * // Create our component * Window w = new Window(gc); * * // Show our window * w.setVisible(true); * * // Create a general double-buffering strategy * w.createBufferStrategy(2); * BufferStrategy strategy = w.getBufferStrategy(); * * // Main loop * while (!done) { * // Prepare for rendering the next frame * // ... * * // Render single frame * do { * // The following loop ensures that the contents of the drawing buffer * // are consistent in case the underlying surface was recreated * do { * // Get a new graphics context every time through the loop * // to make sure the strategy is validated * Graphics graphics = strategy.getDrawGraphics(); * * // Render to graphics * // ... * * // Dispose the graphics * graphics.dispose(); * * // Repeat the rendering if the drawing buffer contents * // were restored * } while (strategy.contentsRestored()); * * // Display the buffer * strategy.show(); * * // Repeat the rendering if the drawing buffer was lost * } while (strategy.contentsLost()); * } * * // Dispose the window * w.setVisible(false); * w.dispose(); * </code></pre> * * @see java.awt.Window * @see java.awt.Canvas * @see java.awt.GraphicsConfiguration * @see VolatileImage * @author Michael Martak * @since 1.4 */ public abstract class BufferStrategy { /** * Returns the {@code BufferCapabilities} for this * {@code BufferStrategy}. * * @return the buffering capabilities of this strategy */ public abstract BufferCapabilities getCapabilities(); /** * Creates a graphics context for the drawing buffer. This method may not * be synchronized for performance reasons; use of this method by multiple * threads should be handled at the application level. Disposal of the * graphics object obtained must be handled by the application. * * @return a graphics context for the drawing buffer */ public abstract Graphics getDrawGraphics(); /** * Returns whether the drawing buffer was lost since the last call to * {@code getDrawGraphics}. Since the buffers in a buffer strategy * are usually type {@code VolatileImage}, they may become lost. * For a discussion on lost buffers, see {@code VolatileImage}. * * @return Whether or not the drawing buffer was lost since the last call * to {@code getDrawGraphics}. * @see java.awt.image.VolatileImage */ public abstract boolean contentsLost(); /** * Returns whether the drawing buffer was recently restored from a lost * state and reinitialized to the default background color (white). * Since the buffers in a buffer strategy are usually type * {@code VolatileImage}, they may become lost. If a surface has * been recently restored from a lost state since the last call to * {@code getDrawGraphics}, it may require repainting. * For a discussion on lost buffers, see {@code VolatileImage}. * * @return Whether or not the drawing buffer was restored since the last * call to {@code getDrawGraphics}. * @see java.awt.image.VolatileImage */ public abstract boolean contentsRestored(); /** * Makes the next available buffer visible by either copying the memory * (blitting) or changing the display pointer (flipping). */ public abstract void show(); /** * Releases system resources currently consumed by this * {@code BufferStrategy} and * removes it from the associated Component. After invoking this * method, {@code getBufferStrategy} will return null. Trying * to use a {@code BufferStrategy} after it has been disposed will * result in undefined behavior. * * @see java.awt.Window#createBufferStrategy * @see java.awt.Canvas#createBufferStrategy * @see java.awt.Window#getBufferStrategy * @see java.awt.Canvas#getBufferStrategy * @since 1.6 */ public void dispose() { } }
⏎ java/awt/image/BufferStrategy.java
Or download all of them as a single archive file:
File name: java.desktop-11.0.1-src.zip File size: 7974380 bytes Release date: 2018-11-04 Download
⇒ JDK 11 java.instrument.jmod - Instrument Module
2022-08-06, 194062👍, 5💬
Popular Posts:
What Is js.jar in Rhino JavaScript 1.7R5? js.jar in Rhino JavaScript 1.7R5 is the JAR file for Rhino...
Guava is a suite of core and expanded libraries that include utility classes, google's collections, ...
SLF4J API is a simple API that allows to plug in any desired logging library at deployment time. Her...
What Is commons-logging-1.2.jar? commons-logging-1.2.jar is the JAR file for Apache Commons Logging ...
Apache Neethi provides general framework for the programmers to use WS Policy. It is compliant with ...