graphics2d.html

来自「API資料大全」· HTML 代码 · 共 1,145 行 · 第 1/5 页

 The current <code>Paint</code> is queried for a
 <code>PaintContext</code>, which specifies
 the colors to render in device space.
 </ol>
 <li>
 <b><a name= renderingimage><code>Image</code> Operations</a></b>
 <ol>
 <li>
 The region of interest is defined by the bounding box of the source 
 <code>Image</code>.
 This bounding box is specified in Image Space, which is the 
 <code>Image</code> object's local coordinate system. 
 <li>
 If an <code>AffineTransform</code> is passed to 
 <A HREF="../../java/awt/Graphics2D.html#drawImage(java.awt.Image, java.awt.geom.AffineTransform, java.awt.image.ImageObserver)"><CODE>drawImage(Image, AffineTransform, ImageObserver)</CODE></A>, 
 the <code>AffineTransform</code> is used to transform the bounding
 box from image space to user space. If no <code>AffineTransform</code> 
 is supplied, the bounding box is treated as if it is already in user space.
 <li>
 The bounding box of the source <code>Image</code> is transformed from user
 space into device space using the current <code>Transform</code>.
 Note that the result of transforming the bounding box does not
 necessarily result in a rectangular region in device space.
 <li>
 The <code>Image</code> object determines what colors to render, 
 sampled according to the source to destination
 coordinate mapping specified by the current <code>Transform</code> and the
 optional image transform.
 </ol>
 </ol>

 <h2>Default Rendering Attributes</h2>
 The default values for the <code>Graphics2D</code> rendering attributes are:
 <dl compact>
 <dt><i><code>Paint</code></i>
 <dd>The color of the <code>Component</code>.
 <dt><i><code>Font</code></i>
 <dd>The <code>Font</code> of the <code>Component</code>.
 <dt><i><code>Stroke</code></i>
 <dd>A square pen with a linewidth of 1, no dashing, miter segment joins
 and square end caps.
 <dt><i><code>Transform</code></i>
 <dd>The 
 <A HREF="../../java/awt/GraphicsConfiguration.html#getDefaultTransform()"><CODE>getDefaultTransform</CODE></A> 
 for the <code>GraphicsConfiguration</code> of the <code>Component</code>.
 <dt><i><code>Composite</code></i>
 <dd>The <A HREF="../../java/awt/AlphaComposite.html#SRC_OVER"><CODE>AlphaComposite.SRC_OVER</CODE></A> rule.
 <dt><i><code>Clip</code></i>
 <dd>No rendering <code>Clip</code>, the output is clipped to the
 <code>Component</code>.
 </dl>

 <h2>Rendering Compatibility Issues</h2>
 The JDK(tm) 1.1 rendering model is based on a pixelization model 
 that specifies that coordinates
 are infinitely thin, lying between the pixels.  Drawing operations are 
 performed using a one-pixel wide pen that fills the 
 pixel below and to the right of the anchor point on the path.  
 The JDK 1.1 rendering model is consistent with the 
 capabilities of most of the existing class of platform 
 renderers that need  to resolve integer coordinates to a 
 discrete pen that must fall completely on a specified number of pixels.  
 <p>
 The Java 2D(tm) (Java(tm) 2 platform) API supports antialiasing renderers. 
 A pen with a width of one pixel does not need to fall 
 completely on pixel N as opposed to pixel N+1.  The pen can fall 
 partially on both pixels. It is not necessary to choose a bias 
 direction for a wide pen since the blending that occurs along the 
 pen traversal edges makes the sub-pixel position of the pen 
 visible to the user.  On the other hand, when antialiasing is 
 turned off by setting the
 <A HREF="../../java/awt/RenderingHints.html#KEY_ANTIALIASING"><CODE>KEY_ANTIALIASING</CODE></A> hint key
 to the
 <A HREF="../../java/awt/RenderingHints.html#VALUE_ANTIALIAS_OFF"><CODE>VALUE_ANTIALIAS_OFF</CODE></A> 
 hint value, the renderer might need 
 to apply a bias to determine which pixel to modify when the pen 
 is straddling a pixel boundary, such as when it is drawn
 along an integer coordinate in device space.  While the capabilities
 of an antialiasing renderer make it no longer necessary for the
 rendering model to specify a bias for the pen, it is desirable for the
 antialiasing and non-antialiasing renderers to perform similarly for
 the common cases of drawing one-pixel wide horizontal and vertical 
 lines on the screen.  To ensure that turning on antialiasing by 
 setting the 
 <A HREF="../../java/awt/RenderingHints.html#KEY_ANTIALIASING"><CODE>KEY_ANTIALIASING</CODE></A> hint
 key to
 <A HREF="../../java/awt/RenderingHints.html#VALUE_ANTIALIAS_ON"><CODE>VALUE_ANTIALIAS_ON</CODE></A>
 does not cause such lines to suddenly become twice as wide and half
 as opaque, it is desirable to have the model specify a path for such
 lines so that they completely cover a particular set of pixels to help
 increase their crispness.
 <p>
 Java 2D API maintains compatibility with JDK 1.1 rendering 
 behavior, such that legacy operations and existing renderer
 behavior is unchanged under Java 2D API.  Legacy
 methods that map onto general <code>draw</code> and 
 <code>fill</code> methods are defined, which clearly indicates 
 how <code>Graphics2D</code> extends <code>Graphics</code> based 
 on settings of <code>Stroke</code> and <code>Transform</code>
 attributes and rendering hints.  The definition 
 performs identically under default attribute settings.  
 For example, the default <code>Stroke</code> is a 
 <code>BasicStroke</code> with a width of 1 and no dashing and the
 default Transform for screen drawing is an Identity transform.  
 <p>
 The following two rules provide predictable rendering behavior whether
 aliasing or antialiasing is being used.
 <ul>
 <li> Device coordinates are defined to be between device pixels which
 avoids any inconsistent results between aliased and antaliased
 rendering.  If coordinates were defined to be at a pixel's center, some
 of the pixels covered by a shape, such as a rectangle, would only be
 half covered.
 With aliased rendering, the half covered pixels would either be 
 rendered inside the shape or outside the shape.  With anti-aliased
 rendering, the pixels on the entire edge of the shape would be half
 covered.  On the other hand, since coordinates are defined to be
 between pixels, a shape like a rectangle would have no half covered
 pixels, whether or not it is rendered using antialiasing. 
 <li> Lines and paths stroked using the <code>BasicStroke</code>
 object may be "normalized" to provide consistent rendering of the
 outlines when positioned at various points on the drawable and
 whether drawn with aliased or antialiased rendering.  This
 normalization process is controlled by the 
 <A HREF="../../java/awt/RenderingHints.html#KEY_STROKE_CONTROL"><CODE>KEY_STROKE_CONTROL</CODE></A> hint.
 The exact normalization algorithm is not specified, but the goals
 of this normalization are to ensure that lines are rendered with
 consistent visual appearance regardless of how they fall on the
 pixel grid and to promote more solid horizontal and vertical
 lines in antialiased mode so that they resemble their non-antialiased
 counterparts more closely.  A typical normalization step might
 promote antialiased line endpoints to pixel centers to reduce the
 amount of blending or adjust the subpixel positioning of
 non-antialiased lines so that the floating point line widths
 round to even or odd pixel counts with equal likelihood.  This
 process can move endpoints by up to half a pixel (usually towards
 positive infinity along both axes) to promote these consistent
 results.
 </ul>
 <p>
 The following definitions of general legacy methods 
 perform identically to previously specified behavior under default 
 attribute settings:
 <ul>
 <li>
 For <code>fill</code> operations, including <code>fillRect</code>, 
 <code>fillRoundRect</code>, <code>fillOval</code>,
 <code>fillArc</code>, <code>fillPolygon</code>, and 
 <code>clearRect</code>, <A HREF="../../java/awt/Graphics2D.html#fill(java.awt.Shape)"><CODE>fill</CODE></A> can now be called
 with the desired <code>Shape</code>.  For example, when filling a
 rectangle:
 <pre>
 fill(new Rectangle(x, y, w, h));
 </pre>
 is called.
 <p>
 <li>
 Similarly, for draw operations, including <code>drawLine</code>, 
 <code>drawRect</code>, <code>drawRoundRect</code>,
 <code>drawOval</code>, <code>drawArc</code>, <code>drawPolyline</code>,
 and <code>drawPolygon</code>, <A HREF="../../java/awt/Graphics2D.html#draw(java.awt.Shape)"><CODE>draw</CODE></A> can now be
 called with the desired <code>Shape</code>.  For example, when drawing a
 rectangle:
 <pre>
 draw(new Rectangle(x, y, w, h));
 </pre>
 is called.
 <p>
 <li>
 The <code>draw3DRect</code> and <code>fill3DRect</code> methods were
 implemented in terms of the <code>drawLine</code> and 
 <code>fillRect</code> methods in the <code>Graphics</code> class which
 would predicate their behavior upon the current <code>Stroke</code>
 and <code>Paint</code> objects in a <code>Graphics2D</code> context.
 This class overrides those implementations with versions that use
 the current <code>Color</code> exclusively, overriding the current
 <code>Paint</code> and which uses <code>fillRect</code> to describe
 the exact same behavior as the preexisting methods regardless of the
 setting of the current <code>Stroke</code>.
 </ul>
 The <code>Graphics</code> class defines only the <code>setColor</code>
 method to control the color to be painted.  Since the Java 2D API extends
 the <code>Color</code> object to implement the new <code>Paint</code> 
 interface, the existing
 <code>setColor</code> method is now a convenience method for setting the 
 current <code>Paint</code> attribute to a <code>Color</code> object.  
 <code>setColor(c)</code> is equivalent to <code>setPaint(c)</code>.
 <p>
 The <code>Graphics</code> class defines two methods for controlling
 how colors are applied to the destination.
 <ol>
 <li>
 The <code>setPaintMode</code> method is implemented as a convenience
 method to set the default <code>Composite</code>, equivalent to
 <code>setComposite(new AlphaComposite.SrcOver)</code>.
 <li>
 The <code>setXORMode(Color xorcolor)</code> method is implemented
 as a convenience method to set a special <code>Composite</code> object that
 ignores the <code>Alpha</code> components of source colors and sets the
 destination color to the value:
 <pre>
 dstpixel = (PixelOf(srccolor) ^ PixelOf(xorcolor) ^ dstpixel);
 </pre>
 </ol>
<P>
<DL>
<DT><B>See Also: </B><DD><A HREF="../../java/awt/RenderingHints.html"><CODE>RenderingHints</CODE></A></DL>
<HR>

<P>
<!-- ======== INNER CLASS SUMMARY ======== -->


<!-- =========== FIELD SUMMARY =========== -->


<!-- ======== CONSTRUCTOR SUMMARY ======== -->

<A NAME="constructor_summary"><!-- --></A>
<TABLE BORDER="1" CELLPADDING="3" CELLSPACING="0" WIDTH="100%">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TD COLSPAN=2><FONT SIZE="+2">
<B>Constructor Summary</B></FONT></TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>protected </CODE></FONT></TD>
<TD><CODE><B><A HREF="../../java/awt/Graphics2D.html#Graphics2D()">Graphics2D</A></B>()</CODE>