summaryrefslogtreecommitdiff
path: root/java/awt/Graphics2D.java
blob: ada13edc51209c97b563668d1708d9aef421abee (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
/* Copyright (C) 2000, 2002, 2004, 2006,  Free Software Foundation

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package java.awt;

import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.ImageObserver;
import java.awt.image.RenderedImage;
import java.awt.image.renderable.RenderableImage;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.text.AttributedCharacterIterator;
import java.util.Map;

/**
 * An abstract class defining a device independent two-dimensional vector 
 * graphics API.  Concrete subclasses implement this API for output of 
 * vector graphics to:
 * <p>
 * <ul>
 * <li>a {@link javax.swing.JComponent} - in the 
 *     {@link javax.swing.JComponent#paint(Graphics)} method, the incoming 
 *     {@link Graphics} should always be an instance of 
 *     <code>Graphics2D</code>;</li> 
 * <li>a {@link BufferedImage} - see 
 *     {@link BufferedImage#createGraphics()};</li>
 * <li>a {@link java.awt.print.PrinterJob} - in the 
 *     {@link Printable#print(Graphics, PageFormat, int)} method, the incoming
 *     {@link Graphics} should always be an instance of 
 *     <code>Graphics2D</code>.</li>
 * </ul>
 * <p>
 * Third party libraries provide support for output to other formats via this 
 * API, including encapsulated postscript (EPS), portable document format (PDF),
 * and scalable vector graphics (SVG).
 * 
 * @author Rolf W. Rasmussen (rolfwr@ii.uib.no)
 */
public abstract class Graphics2D extends Graphics
{

  protected Graphics2D()
  {
  }
  
  public void draw3DRect(int x, int y, int width, int height,
			 boolean raised)
  {
    super.draw3DRect(x, y, width, height, raised);
  }
  
  public void fill3DRect(int x, int y, int width, int height,
			 boolean raised)
  {
    super.fill3DRect(x, y, width, height, raised);
  }

  /**
   * Draws an outline around a shape using the current stroke and paint.
   * 
   * @param shape  the shape (<code>null</code> not permitted).
   * 
   * @see #getStroke()
   * @see #getPaint()
   */
  public abstract void draw(Shape shape);

  public abstract boolean drawImage(Image image, AffineTransform xform,
				    ImageObserver obs);

  public abstract void drawImage(BufferedImage image,
				 BufferedImageOp op,
				 int x,
				 int y);

  public abstract void drawRenderedImage(RenderedImage image,
					 AffineTransform xform);

  public abstract void drawRenderableImage(RenderableImage image,
                                           AffineTransform xform);

  /**
   * Draws a string at the specified location, using the current font.
   * 
   * @param text  the string to draw.
   * @param x  the x-coordinate.
   * @param y  the y-coordinate.
   * 
   * @see Graphics#setFont(Font)
   */
  public abstract void drawString(String text, int x, int y);

  /**
   * Draws a string at the specified location, using the current font.
   * 
   * @param text  the string to draw.
   * @param x  the x-coordinate.
   * @param y  the y-coordinate.
   * 
   * @see Graphics#setFont(Font)
   */
  public abstract void drawString(String text, float x, float y);
    
  /**
   * Draws an attributed string at the specified location.
   * 
   * @param iterator  the source of the attributed text.
   * @param x  the x-coordinate.
   * @param y  the y-coordinate.
   */
  public abstract void drawString(AttributedCharacterIterator iterator,
                                  int x, int y);

  /**
   * Draws an attributed string at the specified location.
   * 
   * @param iterator  the source of the attributed text.
   * @param x  the x-coordinate.
   * @param y  the y-coordinate.
   */
  public abstract void drawString(AttributedCharacterIterator iterator,
				  float x, float y);

  /**
   * Fills the interior of the specified <code>shape</code> using the current
   * paint.
   * 
   * @param shape  the shape to fill (<code>null</code> not permitted).
   * 
   * @see #draw(Shape)
   * @see #getPaint()
   */
  public abstract void fill(Shape shape);
    
  public abstract boolean hit(Rectangle rect, Shape text,
			      boolean onStroke);

  public abstract GraphicsConfiguration getDeviceConfiguration();

  /**
   * Sets the current compositing rule.
   * 
   * @param comp  the composite.
   * 
   * @see #getComposite()
   */
  public abstract void setComposite(Composite comp);

  /**
   * Sets the paint to be used for subsequent drawing operations.
   * 
   * @param paint  the paint (<code>null</code> not permitted).
   * 
   * @see #getPaint()
   */
  public abstract void setPaint(Paint paint);

  /**
   * Sets the stroke to be used for subsequent drawing operations.
   * 
   * @param stroke  the stroke (<code>null</code> not permitted).
   * 
   * @see #getStroke()
   */
  public abstract void setStroke(Stroke stroke);

  /**
   * Adds or updates a hint in the current rendering hints table.
   * 
   * @param hintKey  the hint key.
   * @param hintValue  the hint value.
   */
  public abstract void setRenderingHint(RenderingHints.Key hintKey,
                                        Object hintValue);

  /**
   * Returns the current value of a rendering hint.
   * 
   * @param hintKey  the key for the hint.
   * 
   * @return The value for the specified hint.
   */
  public abstract Object getRenderingHint(RenderingHints.Key hintKey);
  
  /**
   * Replaces the current rendering hints with the supplied hints.
   * 
   * @param hints  the hints.
   * 
   * @see #addRenderingHints(Map)
   */
  public abstract void setRenderingHints(Map hints);

  /**
   * Adds/updates the rendering hint.
   * 
   * @param hints  the hints to add or update.
   */
  public abstract void addRenderingHints(Map hints);

  /**
   * Returns the current rendering hints.
   * 
   * @return The current rendering hints.
   */
  public abstract RenderingHints getRenderingHints();

  public abstract void translate(int x, int y);

  public abstract void translate(double tx, double ty);
    
  public abstract void rotate(double theta);

  public abstract void rotate(double theta, double x, double y);

  public abstract void scale(double scaleX, double scaleY);

  public abstract void shear(double shearX, double shearY);

  /**
   * Sets the current transform to a concatenation of <code>transform</code>
   * and the existing transform.
   * 
   * @param transform  the transform.
   */
  public abstract void transform(AffineTransform transform);
  
  /**
   * Sets the current transform.  If the caller specifies a <code>null</code>
   * transform, this method should set the current transform to the 
   * identity transform.
   * 
   * @param transform  the transform (<code>null</code> permitted).
   * 
   * @see #getTransform()
   */
  public abstract void setTransform(AffineTransform transform);

  /**
   * Returns the current transform.
   * 
   * @return The current transform.
   * 
   * @see #setTransform(AffineTransform)
   */
  public abstract AffineTransform getTransform();

  /**
   * Returns the current paint.
   * 
   * @return The current paint.
   * 
   * @see #setPaint(Paint)
   */
  public abstract Paint getPaint();

  /**
   * Returns the current compositing rule.
   * 
   * @return The current compositing rule.
   * 
   * @see #setComposite(Composite)
   */
  public abstract Composite getComposite();

  /**
   * Sets the background color (used by the 
   * {@link Graphics#clearRect(int, int, int, int)} method).
   * 
   * @param color  the color.
   * 
   * @see #getBackground()
   */
  public abstract void setBackground(Color color);

  /**
   * Returns the color used by the 
   * {@link Graphics#clearRect(int, int, int, int)} method.
   * 
   * @return The background color.
   * 
   * @see #setBackground(Color)
   */
  public abstract Color getBackground();

  /**
   * Returns the current stroke.
   * 
   * @return The current stroke.
   * 
   * @see #setStroke(Stroke)
   */
  public abstract Stroke getStroke();    

  /**
   * Sets the clip region to the intersection of the current clipping region 
   * and <code>s</code>.
   * 
   * @param s  the shape to intersect with the current clipping region.
   * 
   * @see Graphics#setClip(Shape)
   */
  public abstract void clip(Shape s);

  /**
   * Returns the font render context.
   * 
   * @return The font render context.
   */
  public abstract FontRenderContext getFontRenderContext();

  /**
   * Draws a glyph vector at the specified location.
   * 
   * @param g  the glyph vector.
   * @param x  the x-coordinate.
   * @param y  the y-coordinate.
   */
  public abstract void drawGlyphVector(GlyphVector g, float x, float y);
}