001 /* Copyright (C) 2000, 2002, 2004, 2006, Free Software Foundation
002
003 This file is part of GNU Classpath.
004
005 GNU Classpath is free software; you can redistribute it and/or modify
006 it under the terms of the GNU General Public License as published by
007 the Free Software Foundation; either version 2, or (at your option)
008 any later version.
009
010 GNU Classpath is distributed in the hope that it will be useful, but
011 WITHOUT ANY WARRANTY; without even the implied warranty of
012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
013 General Public License for more details.
014
015 You should have received a copy of the GNU General Public License
016 along with GNU Classpath; see the file COPYING. If not, write to the
017 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
018 02110-1301 USA.
019
020 Linking this library statically or dynamically with other modules is
021 making a combined work based on this library. Thus, the terms and
022 conditions of the GNU General Public License cover the whole
023 combination.
024
025 As a special exception, the copyright holders of this library give you
026 permission to link this library with independent modules to produce an
027 executable, regardless of the license terms of these independent
028 modules, and to copy and distribute the resulting executable under
029 terms of your choice, provided that you also meet, for each linked
030 independent module, the terms and conditions of the license of that
031 module. An independent module is a module which is not derived from
032 or based on this library. If you modify this library, you may extend
033 this exception to your version of the library, but you are not
034 obligated to do so. If you do not wish to do so, delete this
035 exception statement from your version. */
036
037
038 package java.awt;
039
040 import java.awt.font.FontRenderContext;
041 import java.awt.font.GlyphVector;
042 import java.awt.geom.AffineTransform;
043 import java.awt.image.BufferedImage;
044 import java.awt.image.BufferedImageOp;
045 import java.awt.image.ImageObserver;
046 import java.awt.image.RenderedImage;
047 import java.awt.image.renderable.RenderableImage;
048 import java.awt.print.PageFormat;
049 import java.awt.print.Printable;
050 import java.text.AttributedCharacterIterator;
051 import java.util.Map;
052
053 /**
054 * An abstract class defining a device independent two-dimensional vector
055 * graphics API. Concrete subclasses implement this API for output of
056 * vector graphics to:
057 * <p>
058 * <ul>
059 * <li>a {@link javax.swing.JComponent} - in the
060 * {@link javax.swing.JComponent#paint(Graphics)} method, the incoming
061 * {@link Graphics} should always be an instance of
062 * <code>Graphics2D</code>;</li>
063 * <li>a {@link BufferedImage} - see
064 * {@link BufferedImage#createGraphics()};</li>
065 * <li>a {@link java.awt.print.PrinterJob} - in the
066 * {@link Printable#print(Graphics, PageFormat, int)} method, the incoming
067 * {@link Graphics} should always be an instance of
068 * <code>Graphics2D</code>.</li>
069 * </ul>
070 * <p>
071 * Third party libraries provide support for output to other formats via this
072 * API, including encapsulated postscript (EPS), portable document format (PDF),
073 * and scalable vector graphics (SVG).
074 *
075 * @author Rolf W. Rasmussen (rolfwr@ii.uib.no)
076 */
077 public abstract class Graphics2D extends Graphics
078 {
079
080 protected Graphics2D()
081 {
082 }
083
084 public void draw3DRect(int x, int y, int width, int height,
085 boolean raised)
086 {
087 super.draw3DRect(x, y, width, height, raised);
088 }
089
090 public void fill3DRect(int x, int y, int width, int height,
091 boolean raised)
092 {
093 super.fill3DRect(x, y, width, height, raised);
094 }
095
096 /**
097 * Draws an outline around a shape using the current stroke and paint.
098 *
099 * @param shape the shape (<code>null</code> not permitted).
100 *
101 * @see #getStroke()
102 * @see #getPaint()
103 */
104 public abstract void draw(Shape shape);
105
106 public abstract boolean drawImage(Image image, AffineTransform xform,
107 ImageObserver obs);
108
109 public abstract void drawImage(BufferedImage image,
110 BufferedImageOp op,
111 int x,
112 int y);
113
114 public abstract void drawRenderedImage(RenderedImage image,
115 AffineTransform xform);
116
117 public abstract void drawRenderableImage(RenderableImage image,
118 AffineTransform xform);
119
120 /**
121 * Draws a string at the specified location, using the current font.
122 *
123 * @param text the string to draw.
124 * @param x the x-coordinate.
125 * @param y the y-coordinate.
126 *
127 * @see Graphics#setFont(Font)
128 */
129 public abstract void drawString(String text, int x, int y);
130
131 /**
132 * Draws a string at the specified location, using the current font.
133 *
134 * @param text the string to draw.
135 * @param x the x-coordinate.
136 * @param y the y-coordinate.
137 *
138 * @see Graphics#setFont(Font)
139 */
140 public abstract void drawString(String text, float x, float y);
141
142 /**
143 * Draws an attributed string at the specified location.
144 *
145 * @param iterator the source of the attributed text.
146 * @param x the x-coordinate.
147 * @param y the y-coordinate.
148 */
149 public abstract void drawString(AttributedCharacterIterator iterator,
150 int x, int y);
151
152 /**
153 * Draws an attributed string at the specified location.
154 *
155 * @param iterator the source of the attributed text.
156 * @param x the x-coordinate.
157 * @param y the y-coordinate.
158 */
159 public abstract void drawString(AttributedCharacterIterator iterator,
160 float x, float y);
161
162 /**
163 * Fills the interior of the specified <code>shape</code> using the current
164 * paint.
165 *
166 * @param shape the shape to fill (<code>null</code> not permitted).
167 *
168 * @see #draw(Shape)
169 * @see #getPaint()
170 */
171 public abstract void fill(Shape shape);
172
173 public abstract boolean hit(Rectangle rect, Shape text,
174 boolean onStroke);
175
176 public abstract GraphicsConfiguration getDeviceConfiguration();
177
178 /**
179 * Sets the current compositing rule.
180 *
181 * @param comp the composite.
182 *
183 * @see #getComposite()
184 */
185 public abstract void setComposite(Composite comp);
186
187 /**
188 * Sets the paint to be used for subsequent drawing operations.
189 *
190 * @param paint the paint (<code>null</code> not permitted).
191 *
192 * @see #getPaint()
193 */
194 public abstract void setPaint(Paint paint);
195
196 /**
197 * Sets the stroke to be used for subsequent drawing operations.
198 *
199 * @param stroke the stroke (<code>null</code> not permitted).
200 *
201 * @see #getStroke()
202 */
203 public abstract void setStroke(Stroke stroke);
204
205 /**
206 * Adds or updates a hint in the current rendering hints table.
207 *
208 * @param hintKey the hint key.
209 * @param hintValue the hint value.
210 */
211 public abstract void setRenderingHint(RenderingHints.Key hintKey,
212 Object hintValue);
213
214 /**
215 * Returns the current value of a rendering hint.
216 *
217 * @param hintKey the key for the hint.
218 *
219 * @return The value for the specified hint.
220 */
221 public abstract Object getRenderingHint(RenderingHints.Key hintKey);
222
223 /**
224 * Replaces the current rendering hints with the supplied hints.
225 *
226 * @param hints the hints.
227 *
228 * @see #addRenderingHints(Map)
229 */
230 public abstract void setRenderingHints(Map<?,?> hints);
231
232 /**
233 * Adds/updates the rendering hint.
234 *
235 * @param hints the hints to add or update.
236 */
237 public abstract void addRenderingHints(Map<?,?> hints);
238
239 /**
240 * Returns the current rendering hints.
241 *
242 * @return The current rendering hints.
243 */
244 public abstract RenderingHints getRenderingHints();
245
246 public abstract void translate(int x, int y);
247
248 public abstract void translate(double tx, double ty);
249
250 public abstract void rotate(double theta);
251
252 public abstract void rotate(double theta, double x, double y);
253
254 public abstract void scale(double scaleX, double scaleY);
255
256 public abstract void shear(double shearX, double shearY);
257
258 /**
259 * Sets the current transform to a concatenation of <code>transform</code>
260 * and the existing transform.
261 *
262 * @param transform the transform.
263 */
264 public abstract void transform(AffineTransform transform);
265
266 /**
267 * Sets the current transform. If the caller specifies a <code>null</code>
268 * transform, this method should set the current transform to the
269 * identity transform.
270 *
271 * @param transform the transform (<code>null</code> permitted).
272 *
273 * @see #getTransform()
274 */
275 public abstract void setTransform(AffineTransform transform);
276
277 /**
278 * Returns the current transform.
279 *
280 * @return The current transform.
281 *
282 * @see #setTransform(AffineTransform)
283 */
284 public abstract AffineTransform getTransform();
285
286 /**
287 * Returns the current paint.
288 *
289 * @return The current paint.
290 *
291 * @see #setPaint(Paint)
292 */
293 public abstract Paint getPaint();
294
295 /**
296 * Returns the current compositing rule.
297 *
298 * @return The current compositing rule.
299 *
300 * @see #setComposite(Composite)
301 */
302 public abstract Composite getComposite();
303
304 /**
305 * Sets the background color (used by the
306 * {@link Graphics#clearRect(int, int, int, int)} method).
307 *
308 * @param color the color.
309 *
310 * @see #getBackground()
311 */
312 public abstract void setBackground(Color color);
313
314 /**
315 * Returns the color used by the
316 * {@link Graphics#clearRect(int, int, int, int)} method.
317 *
318 * @return The background color.
319 *
320 * @see #setBackground(Color)
321 */
322 public abstract Color getBackground();
323
324 /**
325 * Returns the current stroke.
326 *
327 * @return The current stroke.
328 *
329 * @see #setStroke(Stroke)
330 */
331 public abstract Stroke getStroke();
332
333 /**
334 * Sets the clip region to the intersection of the current clipping region
335 * and <code>s</code>.
336 *
337 * @param s the shape to intersect with the current clipping region.
338 *
339 * @see Graphics#setClip(Shape)
340 */
341 public abstract void clip(Shape s);
342
343 /**
344 * Returns the font render context.
345 *
346 * @return The font render context.
347 */
348 public abstract FontRenderContext getFontRenderContext();
349
350 /**
351 * Draws a glyph vector at the specified location.
352 *
353 * @param g the glyph vector.
354 * @param x the x-coordinate.
355 * @param y the y-coordinate.
356 */
357 public abstract void drawGlyphVector(GlyphVector g, float x, float y);
358 }