| javax.swing.JPanel
 com.sun.j3d.exp.swing.JCanvas3D
| JCanvas3D | | public class JCanvas3D extends JPanel implements AncestorListener(Code) | | This class provides a lightweight capability to Java 3D. The component
handles bidirectional messaging between swing and Java 3D so that repaint
ordonned by swing are sent to the universe if necessary and refreshes from
the universe are painted accordingly. In order to get responsive interfaces
during layout changes, the canvas has a feature (disabled by default) that
lets true resizes occur only after a timer expires. Images between real
resizes can eventually be slightly wrong and pixelated, but their display
will be stutterless.
Lightweight canvas also handles redirection to heavyweight canvas for the
following events:
- InputMethodEvent
- KeyEvent
- FocusEvent
- ComponentKeyEvent
- MouseWheelEvent
- MouseEvent
- MouseMotionEvent
When Swing is waiting for a canvas to be retrieved and that canvas is in
rendering stage,a loop takes place, which includes small calls to wait().
The canvas status is tested for readiness before and after the wait(). If
the canvas is not ready to be retrieved after the wait(), counter is
decremented and control is given back to awt thread, which will repaint old
buffer. If the loop goes over a certain amount of iterations, the canvas is
declared 'crashed' and won't be updated anymore. This was done so that a
crashed canvas/universe does not remove control over your GUI and does not
leave you with a frozen application. In current implementation, the delay
before a canvas is declared crashed is of :
30 Math.max(20.0, getView().getMinimumFrameCycleTime() )
author:
Frederic 'pepe' Barachant
See Also: getLightweightComponent()
See Also: setResizeValidationDelay()
See Also: setResizeMode()
since:
Java 3D 1.5 |
| Inner Class :static class ResizeSwingRunnable implements Runnable | |
| Inner Class :static class ResizeThread extends Thread | |
| Field Summary | |
| final public static int | RESIZE_DELAYED
Resizing the canvas or component will be done if no resizing
occurs after expiration of a certain delay. | | final public static int | RESIZE_IMMEDIATELY
Resizing the canvas or component will be done immediately. | | int | resizeMode
The resize mode currently being used. | | int | resizeValidationDelay
the idle delay that will trigger a real resize. |
| Constructor Summary | |
| public | JCanvas3D()
Constructs and initializes a new JCanvas3D object that Java 3D
can render into. | | public | JCanvas3D(GraphicsDevice device)
Constructs and initializes a new Canvas3D object that Java 3D
can render into, using the specified graphics device. | | public | JCanvas3D(GraphicsConfigTemplate3D template)
Constructs and initializes a new Canvas3D object that Java 3D
can render into, using the specified template.
The screen device is obtained from
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(),
which might not be the one you should use if you are
in a multiscreen environment.
Parameters:
template - The template that will be used to construct aGraphicsConfiguration. | | public | JCanvas3D(GraphicsConfigTemplate3D template, GraphicsDevice device)
Constructs and initializes a new Canvas3D object that Java 3D
can render into, using the specified template and graphics device.
Parameters:
template - The template that will be used to construct aGraphicsConfiguration. |
| RESIZE_DELAYED | | final public static int RESIZE_DELAYED(Code) | | Resizing the canvas or component will be done if no resizing
occurs after expiration of a certain delay. Rendering will be
eventually stretched or deformed. It can be useful on certain
applications where smooth update of UI during layout is needed or
desired.
See Also: setResizeMode() |
| RESIZE_IMMEDIATELY | | final public static int RESIZE_IMMEDIATELY(Code) | | Resizing the canvas or component will be done immediately. This
operation might take some time and make the application look sluggish.
See Also: setResizeMode() |
| resizeMode | | int resizeMode(Code) | | The resize mode currently being used.
|
| resizeValidationDelay | | int resizeValidationDelay(Code) | | the idle delay that will trigger a real resize. ('idle' being
the lack of resizing action from the user)
|
| JCanvas3D | | public JCanvas3D()(Code) | | Constructs and initializes a new JCanvas3D object that Java 3D
can render into. The screen device is obtained from
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(),
which might not be the one you should use if you are in a multiscreen environment.
The JCanvas3D is constructed using the following default parameters:
resize mode : RESIZE_IMMEDIATELY
validation delay : 100ms
double buffer enable : false
stereo enable : false
|
| JCanvas3D | | public JCanvas3D(GraphicsDevice device)(Code) | | Constructs and initializes a new Canvas3D object that Java 3D
can render into, using the specified graphics device.
Parameters:
device - the screen graphics device that will be used to constructa GraphicsConfiguration. |
| JCanvas3D | | public JCanvas3D(GraphicsConfigTemplate3D template)(Code) | | Constructs and initializes a new Canvas3D object that Java 3D
can render into, using the specified template.
The screen device is obtained from
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(),
which might not be the one you should use if you are
in a multiscreen environment.
Parameters:
template - The template that will be used to construct aGraphicsConfiguration. The stereo and doublebuffer propertiesare forced to UNNECESSARY. |
| JCanvas3D | | public JCanvas3D(GraphicsConfigTemplate3D template, GraphicsDevice device)(Code) | | Constructs and initializes a new Canvas3D object that Java 3D
can render into, using the specified template and graphics device.
Parameters:
template - The template that will be used to construct aGraphicsConfiguration. The stereo and doublebuffer propertiesare forced to UNNECESSARY.
Parameters:
device - the screen graphics device that will be used to constructa GraphicsConfiguration in conjunction with the template. |
| createCanvas | | void createCanvas(int width, int height)(Code) | | Creates a heavyweight canvas and initializes it, or changes the
size of the current one if present. Current heavyweight canvas is
changed only if size is different from the actual one. No canvas is
created if this component has no parent, that is, was not added to a
container.
Parameters:
width - the width of the canvas to create.
Parameters:
height - the height of the canvas to create. |
| getOffscreenCanvas3D | | public Canvas3D getOffscreenCanvas3D()(Code) | | Returns the offscreen heavyweight canvas of that lightweight
component.
the heavyweight canvas that lies in the deepness of thisComponent. |
| getResizeMode | | public int getResizeMode()(Code) | | Retrieves the resize mode for that component.
the resize mode, which can be one of RESIZE_IMMEDIATELY orRESIZE_DELAYED |
| getResizeValidationDelay | | public int getResizeValidationDelay()(Code) | | Retrieves the validation delay for that canvas, whatever the
resize mode is set to.
the validation delay. |
| paintComponent | | public void paintComponent(java.awt.Graphics g)(Code) | | Paints the result of the rendering. If the rendered buffer is
not useable (render thread being between [code]postRender()[/code] and
[code]postSwap()[/code]), it will wait for it to be ready. Otherwise it
will directly paint the previous buffer.
Parameters:
g - |
| processComponentKeyEvent | | protected void processComponentKeyEvent(java.awt.event.KeyEvent e)(Code) | | Redirects event to canvas and to superclass.
Parameters:
e - |
| processMouseMotionEvent | | protected void processMouseMotionEvent(java.awt.event.MouseEvent e)(Code) | | Redirects event to canvas and to superclass.
Parameters:
e - |
| setBounds | | public void setBounds(int x, int y, int width, int height)(Code) | |
Parameters:
x -
Parameters:
y -
Parameters:
width -
Parameters:
height - |
| setResizeMode | | public void setResizeMode(int resizeMode)(Code) | | Sets resize mode to be used on this component. Resize mode
permits to have smoother canvas resizes. The time taken by a canvas to
be resized can be pretty long: renderer has to stop, current render has
to end, everything has to be initialized again, and after all that has
been done, renderer is started again, then the image is displayed once
rendered. Resize mode uses a timer to make those steps only after the
last refresh request occured. 'Latest refresh' is determined by the
amount of time between now and the last time you asked for a size
change. If that time expires, a real resize is done. In between, the
same size is rendered, but the drawn image is scaled down/up. This has
some drawbacks, as the image can appear blocked, imprecise, distorted,
incomplete for that while, but most of the time only some of the
drawbacks will be users will see nothing. Default delay is set to
100ms, which is low enough for common human not to be able to really
see that the rendered image is scaled.
Parameters:
resizeMode - can be one of RESIZE_IMMEDIATELY or RESIZE_DELAYED
See Also: JCanvas3D.RESIZE_IMMEDIATELY
See Also: JCanvas3D.RESIZE_DELAYED |
| setResizeValidationDelay | | public void setResizeValidationDelay(int resizeValidationDelay)(Code) | | Sets the validation delay for the component. The validation
delay is the maximum time allowed for the canvas resizing to occur
using rendered buffer scaling. Once that delay expired, the canvas is
resized at the lowest level possible, thus in the rendering pipeline.
Note: Changing this field is only useful if resize mode is set to
RESIZE_IMMEDIATELY or RESIZE_DELAYED
Parameters:
resizeValidationDelay - the delay before a real resize would occur.
See Also: JCanvas3D.RESIZE_IMMEDIATELY
See Also: JCanvas3D.RESIZE_DELAYED |
|
|