Advanced Java

Mohit Chowdhary, Poonam Chaudhary,

Assistant Prof Deptt of Computer Science
1
Unit-4: Core Java

4.1 The Rendering Pipeline

The original JDK 1.0 had a very simple mechanism for drawing shapes. You
select color and paint mode, and call methods of the Graphics class such as
drawRect or fillOval.

The Java 2D API supports many more options.
You can easily produce a wide variety of shapes.
You have control over the stroke, the pen that traces shape boundaries.
You can fill shapes with solid colors, varying hues, and repeating
patterns.
You can use transformations to move, scale, rotate, or stretch shapes.
You can clip shapes to restrict them to arbitrary areas.
You can select composition rules to describe how to combine the pixels of
a new shape with existing pixels.
You can give rendering hints to make trade-offs between speed and
drawing quality.

To draw a shape, you go through the following steps:
1. Obtain an object of the Graphics2D class. This class is a subclass of the
Graphics class. If you use a version of the JDK that is enabled for Java 2D
technology, methods such as paint and paintComponent automatically
receive an object of the Graphics2D class. Simply use a cast, as follows:

public void paintComponent(Graphics g)
{
Graphics2D g2 = (Graphics2D)g;
. . .
}

2. Use the setRenderingHints method to set rendering hints: trade-offs between
speed and drawing quality.

RenderingHints hints = . . .;
g2.setRenderingHints(hints);

3. Use the setStroke method to set the stroke. The stroke is used to draw the
outline of the shape. You can select the thickness and choose among solid
and dotted lines.

Stroke stroke = . . .;
g2.setStroke(stroke);


Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
2
4. Use the setPaint method to set the paint. The paint is used to fill areas such
as the stroke path or the interior of a shape. You can create solid color paint,
paint with changing hues, or tiled fill patterns.

Paint paint = . . .;
g2.setPaint(paint);

5. Use the setClip method to set the clipping region.

Shape clip = . . .;
g2.clip(clip);

6. Use the setTransform method to set a transformation from user space to
device space. You use transformations if it is easier for you to define your
shapes in a custom coordinate system than by using pixel coordinates.

AffineTransform transform = . . .;
g2.transform(transform);

7. Use the setComposite method to set a composition rule that describes how to
combine the new pixels with the existing pixels.

Composite composite = . . .;
g2.setComposite(composite);

8. Create a shape. The Java 2D API supplies many shape objects and methods
to combine shapes.

Shape shape = . . .;

9. Draw or fill the shape. If you draw the shape, its outline is stroked. If you fill
the shape, the interior is painted.

g2.draw(shape);
g2.fill(shape);

The various set methods simply set the state of the 2D graphics context. They don't
cause any drawing. Similarly, when you construct Shape objects, no drawing takes
place. A shape is only rendered when you call draw() or fill(). At that time, the
new shape is computed in a rendering pipeline.

java.awt.Graphics2D package contains two methods:

a) void draw(Shape s) draws the outline of the given shape.
b) void fill(Shape s) fills the interior of the given shape.




Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
3

In the rendering pipeline, the following steps take place to render a shape:

1) The path of the shape is stroked.
2) The shape is transformed.
3) The shape is clipped. If there is no intersection b/w the shape & the
clipping area, then the process stops.
4) The remainder of the shape after clipping is filled.
5) The pixels of the filled shape are composed with the existing pixels.





4.2 Shapes

Here are some of the methods in the Graphics class to draw shapes:

drawLine
drawRectangle
drawRoundRect
draw3DRect
drawPolygon
drawPolyline
drawOval
drawArc

There are also corresponding fill methods. These methods have been in the
Graphics class ever since JDK 1.0. The Java 2D API uses a completely
different, object-oriented approach. Instead of methods, there are classes:

Line2D
Rectangle2D
RoundRectangle2D
Ellipse2D
Arc2D
QuadCurve2D
CubicCurve2D
GeneralPath

These classes all implement the Shape interface.

Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
4
Finally, there is a Point2D class that describes a point with an x- and a y-
coordinate. Points are useful to define shapes, but they aren't themselves
shapes.

To draw a shape, you first create an object of a class that implements the
Shape interface and then call the draw method of the Graphics2D class.

Each of the classes whose name ends in "2D" has two subclasses for specifying
coordinates as float or double quantities.

Internally all graphics classes use float coordinates because float numbers use
less storage space, but java programming language makes it a bit more tedious
to manipulate float numbers.

For this reason most methods of the graphics classes use double parameters &
return values.

Only when constructing a 2D object you must choose between a constructor
with float or double coordinates.

For ex:
Rectangle2D floatRect=new
Rectangle2D.Float(5F,10F,7.5F,15F);

Rectangle2D doubleRect=new
Rectangle2D.Double(5,10,7.5,15);

4.2.1 Using the Shape Classes

For the RoundRectangle2D shape, you specify the top left corner, width &
height & the x & y dimensions of the corner area that should be rounded.

RoundRectangle2D r = new
RoundRectangle2D.Double(150,200,100,50,20,20);

here w=150, h=200, x=100, y=50, r=20.

The code above, produces a rounded rectangle with circles of radius 20 at each
of the corners.

The Java 2D API supplies two additional classes:

Quadratic & cubic curves.

Quadratic & cubic curves are specified by two end points & one or two control
points. Moving the control points changes the shape of the curves.

To construct quadratic & cubic curves, you give the coordinates of the end
points & the control points.
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
5
For Ex:

Quadcurve2d q =new QuadCurve2d.Double(startX, startY, controlX, controlY,
endX, endY );

CubicCurve2D c = new CubicCurve2D.Double(startX, startY,control1X,
control1Y, control2X,control2Y endX, endY);



A quadratic curve A cubic curve

Quadratic curves are not very flexible & they are not commonly used, whereas
cubic curves are common.

You can build arbitrary sequences of line segments, quadratic curves & cubic
curves & store them in a GeneralPath object. You specify the first coordinate of
the path with the moveTo method. GeneralPath class describes paths that are
made up from lines, quadratic & cubic curves.
For Ex:
GeneralPath path =new GeneralPath();
path.moveTo(10, 20);

You then extend the path by calling one of the methods lineTo, quadTo or
curveTo. These methods extend the path by a line, a quadratic curve, or a
cubic curve.

To call lineTo, supply the endpoint.

For Ex:

Path.lineTo(20, 30);





Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
6
4.3 Areas

In the preceding section, you saw how you can specify complex shapes by
constructing general paths that are composed of lines and curves.

However, occasionally, it is easier to describe a shape by composing it from
areas, such as rectangles, polygons, or ellipses. The Java 2D API supports four
constructive area geometry operations that combine two areas to a new area:

add The combined area contains all points that are in the first or the
second area.
subtract The combined area contains all points that are in the first but
not the second area.
intersect The combined area contains all points that are in the first
and the second area.
exclusiveOr The combined area contains all points that are in either
the first or the second area, but not in both.



To construct a complex area, you start out with a default area object.

Area a = new Area();

Then, you combine the area with any shape:

a.add(new Rectangle2D.Double(. . .));
a.subtract(path);
. . .
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
7
The Area class implements the Shape interface. You can stroke the boundary of
the area with the draw method or paint the interior with the fill method of the
Graphics2D class.




4.4 Strokes

The draw operation of the Graphics2D class draws the boundary of a shape by
using the currently selected stroke. By default, the stroke is a solid line that is
one pixel wide. You can select a different stroke by calling the setStroke
method. You supply an object of a class that implements the Stroke interface.
The Java 2D API defines only one such class, called BasicStroke.

You can construct strokes of arbitrary thickness. For example, here is how you
draw lines that are 10 pixels wide.

g2.setStroke(new BasicStroke(10.0F));
g2.draw(new Line2D.Double(. . .));

When a stroke is more than a pixel thick, then the end of the stroke can have
different styles. These are called end cap styles. There are three choices:




Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
8



A butt cap simply ends the stroke at its end point.
A round cap adds a half-circle to the end of the stroke.
A square cap adds a half-square to the end of the stroke.

When two thick strokes meet, there are three choices for the join style:





Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
9
A bevel join joins the strokes with a straight line that is perpendicular to
the bisector of the angle between the two strokes.
A round join extends each stroke to have a round cap.
A miter join extends both strokes by adding a "spike."

The miter join is not suitable for lines that meet at small angles. If two lines
join with an angle that is less than the miter limit, then a bevel join is used
instead. That usage prevents extremely long spikes. By default, the miter limit
is ten degrees.

These choices can be specified in the BasicStroke constructor, for example:

g2.setStroke(new BasicStroke(10.0F, BasicStroke.CAP_ROUND,
BasicStroke.JOIN_ROUND));

g2.setStroke(new BasicStroke(10.0F, BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER, 15.0F /* miter limit */));

Finally, one can specify dashed lines by setting a dash pattern.

The dash pattern is a float[ ] array of numbers that contains the lengths of the
on & off strokes.

The dash pattern & a dash phase are specified when constructing the
BasicStroke. The dash phase indicates where in the dash pattern each line
should start.

For Ex:

float[ ] dashPattern= {10,10,10,10,10, 10, 30, 10 ,30 ..};

g2.setStroke(new
BasicStroke(10.0F,BasicStroke.CAP_BUTT,basicStroke.JOIN_MITER,
10.0F));




4.5 Paint

When you fill a shape, its inside is covered with paint.
Use the setPaint() method to set the paint style to an object with a class that
implements the Paint interface.


Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
10
The java 2D API provides three such classes:

a) Color class To fill shapes with a solid color, simply call setPaint
with a color object, such as:
g2.setPaint(Color.red);

b) GradientPaint class It varies colors by interpolating b/w two
given colors values. u construct a GradientPaint object by specifying
two points & the colors u want at these two points, such as:
g2.setPaint(new GradientPaint(p1,color.red, p2, color.pink));

Colors are interpolated along the line joining the two points. Colors
are constant along lines that are perpendicular to that joining line.




c) TexturePaint class It fills an area with repetitions of an image. To
construct a TexturePaint object, you specify a BufferedImage & an
anchor rectangle. The anchor rectangle is extended indefinitely in x &
y directions to tile the entire coordinate plane. The image is scaled to
fit into the anchor & then replicated into each tile.

Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
11



You create a BufferedImage object by giving the image size & image type. The
most common image type is TYPE_INT_ARGB, in which each pixel is specified
by an integer that describes the alpha or red, green & blue values.

For Ex:

BufferedImage bufferedImage = new BufferedImage(width,
height, BufferedImage.TYPE_INT_ARGB);

You then obtain a graphics context to draw into the buffered image:

Graphics 2D g2 = bufferedImage.createGraphics();

Any drawing operations on g2 now fill the buffered image with pixels. Now you
can create your TexturePaint object:

g2.setPaint(new TexturePaint( bufferedImage, anchorRectangle));









Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
12


4.6 Coordinate Transformation

They allow you to work with convenient coordinate values. Suppose you need
to draw an object such as automobile. You know from the manufacturers
specifications, the height, wheelbase & total length. You could now figure out
all pixel positions, assuming some numbers per meter.

g2.scale(pixelsPerMeter, pixelsPerMeter) ;
g2.draw(new Line2D.Double(coordintes in meters)) ;

There are Four transformations:

Scaling blowing up or shrinking ,all distances from a fixed point. The
scale method of the Graphics 2D class sets the coordinate
transformation of the graphics context to a scaling transformation. That
transformation changes user coordinates (user-specified units) to device
coordinates (pixels).

Rotation rotating all points around a fixed center.

Translation moving all points by a fixed amount.

Shear leaving one line fixed & sliding the lines parallel to it by an
amount that is proportional to the distance from the fixed line.



The scale, rotate, translate & shear methods of the Graphics 2D class set the
coordinate translation of the graphics context to one of these fundamental
transformations. You can compose the transformations.

Ex: Suppose u want to rotate shapes & double their size. Then

You supply both a rotation & scaling transformation.

g2.rotate(angle);
g2.scale(2, 2);
g2.draw();

Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
13
The graphics context will apply the transformations in the opposite order in
which u supplied them. That is the last transformation that you supply is
applied first. U can supply as many transformations as you like.
For Ex:
g2.translate(x, y);
g2.rotate(a);
g2.translate(-x, -y);

The last transformation (is applied first) moves the point (x ,y) to the origin. The
second transformation rotates with an angle a around the origin. The final
transformation moves the origin back to (x,y).

Affine Transformation In this all rotations, translations, scalings, shears &
their compositions can be expressed by a matrix transformations.

In Java 2D API, the AffineTransform class describes such a transformation. If
u know the components of a particular transformation matrix, u can construct
it directly as:

AffineTransform t = new AffineTransform(a, b, c d, e, f );

The factory methods such as getRotateInstance, getScaleInstance,
getTranslateInstance & getShearInstance construct the matrices that represent
these transformation types.

For ex:

t = AffineTransform.getScaleInstance(2.0F, 0.5F);

returns a transformation that corresponds to the matrix :
[ 2 0 0 ]
[ 0 0.5 0 ]
[ 0 0 1 ]

The instance methods such as setToRotation, setToScale, setToTranslation &
setToShear set a transformation object to a new type.

Ex:
t.setToTranslation(angle) // sets to a rotation

you can set the coordinate transformation of the graphics context to an
AffineTransform object.

g2.setTransform(t);

However in practice, you should not call the setTransform operation, since it
replaces any existing transformation that the graphics context may have.
Instead call the transform method.

Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
14
g2.transform(t);
if you just want to apply a transformation temporarily, then you first get the
old transformation, compose with your new transformation & finally restore the
old transformation when you are done.

AffineTransform oldTransform = g2.setTransform() ;
g2.transform(t) ;
g2.setTransform(oldTransform) ;

4.7 Clipping

Clipping is a technique by which the drawing area can be restricted to a small
portion of the screen.

A clipping region is an area where drawing is allowed.

Any drawing outside the clipping region is clipped off & not displayed.

By setting a clipping shape in the graphics context, you constraint all drawing
operations to the interior of that clipping shape.

g2.setClip(clipShape) ;
g2.draw(shape) ;

However, in practice you dont want to call the setClip operation, since it
replaces any existing clipping shape that the graphics context may have.
Instead call the clip method.

g2.clip(clipShape) ;

The clip method intersects the existing clipping shape with the new one that
you supply.

If you just want to apply a clipping area temporarily, then you should first get
the old clip, then add your new clip, & finally restore the old clip when you are
done :

Shape oldClip = g2.getClip() ; // save old clip
g2.clip(clipShape) ; // apply temporarily clip
gr.setClip(oldClip) ; //restore old clip

The Graphics class method clipRect() creates rectangular clipping regions.

For Ex:

g.clipRect(50,50,100,75)

sets a clipping rectangle of width 100 & height 75 with top left corner at 50,50.

Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
15



Program for Clipping

import java.awt.*;
import java.applet.*;
public class Clipper extends Applet {
/*
<applet code=Clipper width=300 height=150>
</applet>
*/

public void paint(Graphics g) {
g.clipRect(10,10,150,100);
g.setFont(new Font(TimesRoman,Font,ITALIC,28));
g.fillOval(100,60,80,80);
g.drawString(Happy new Year,50,30);
}
}

4.8 Transparency & Composition

It is convenient to describe areas of an image that are transparent or partially
transparent.

When you superimpose an image onto an existing drawing, the transparent
pixels do not obscure the pixels under them at all, whereas partially
transparent pixels are mixed with the pixels under them.

In Java 2D API, transparency is described by an alpha channel.

Each pixel has an alpha value b/w 0(fully transparent) & 1(fully opaque).
Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
16
If you superimpose two shapes, you need to blend or compose the colors &
alpha values of the source & destination pixels.
Porter & Duff two researchers in the field of computer graphics, have
formulated 12 possible composition rules for this blending process. The java
2D API implements all of these rules. These rules are:

1) CLEAR source clears destination.
2) SRC source overwrites destination & empty pixels.
3) DST Source does not affect destination.
4) SRC_OVER Source blends with destination & overwrites empty pixels.
5) DST_OVER Source does not affect destination & overwrites empty pixels.
6) SRC_IN Source overwrites destination.
7) SRC_OUT Source clears destination & overwrites empty pixels.
8) DST_IN Source alpha modifies destination.
9) DST_OUT Source alpha complement modifies destination.
10) SRC_ATOP Source blends with destination.
11) DST_ATOP Source alpha modifies destination. Source overwrites empty
pixels.
12) XOR Source alpha complement modifies destination. Source overwrites
empty pixels.




The Java 2D API supplies a class called AlphaComposite, that implements all
Porter Duff rules. The factory method getInstance of the alpha value to be
used for source pixels.

For Ex:
int rule = AlphaComposite.SRC_OVER;
float alpha =0.5f;
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
17
g2.setComposite(AlphaComposite.getInstance(rule, alpha));
g2.setPaint(Color.blue);
g2.fill(rectangle);

The rectangle is painted with blue color & an alpha value of 0.5. Because the
composition rule is SRC_OVER, it is transparently overlaid on the existing
image.

4.9 Rendering Hints

There are cases when u would like to have control over tradeoffs b/w speed &
quality. You achieve this by setting rendering hints.

The setRenderingHint() method of the Graphics2D class lets u set a single hint.
The hint keys & values are declared in the RenderingHints class.

Antialiasing This technique removes the jaggies from slanted lines &
curves.
A slanted line must be drawn as a staircase of pixels. Rather than drawing
each pixel completely on or off. You can color in the pixels that are partially
covered, with the color value proportional to the area of the pixel that the line
covers, and then the result looks much smoother.

Antialiasing takes a bit longer because it takes time to compute all those color
values.

You can request the antialising like :

g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);

For Ex:
RenderingHints hints =new RenderingHints();

hints.put(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);

hints.put(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHi
nts.VALUE_TEXT_ANTIALIAS_ON);

g2.setRenderingHints(hints);








Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
18



Key Values Explanation
KEY_ANTIALIASING
VALUE_ANTIALIAS_ON
Turn antialiasing for
shapes on or off.
VALUE_ANTIALIAS_OFF
VALUE_ANTIALIAS_DEFAULT
KEY_RENDERING
VALUE_RENDER_QUALITY
When available, select
render-ing algorithms
for greater quality or
speed.
VALUE_RENDER_SPEED
VALUE_RENDER_DEFAULT
KEY_DITHERING
VALUE_DITHER_ENABLE
Turn dithering for colors
on or off. Dithering
approximates color
values by drawing
groups of pixels of
similar colors.
VALUE_DITHER_DISABLE
VALUE_DITHER_DEFAULT
KEY_TEXT_ANTIALIASING
VALUE_TEXT_ANTIALIAS_ON
Turn antialiasing for
fonts 011 or off.
VALUE_TEXT_ANTIALIAS_OF
F
VALUE_TEXT_ANTIALIAS_DE
FAULT
KEY_FRACTIONALMETRI
CS
VALUE_FRACTIONALMETRIC
S_ON
Turn the computation of
fractional character
dimensions on or off.
Fractional" character-
dimensions lead to
better placement of
characters.
VALUE_FRACTIONALMETRIC
S_OFF
VALUE_FRACTIONALMETRIC
S_DEFAULT
KEY_ALPHA_INTERPOLAT
ION
VALUE-
ALPHA_INTERPOLATION_QU
ALITY Turn precise
computation of alpha
composites on or off.
VALUE_ALPHA_INTERPOLATI
ON_SPEED
VALUE_ALPHA_INTERPOLATI
ON_DEFAULT
KEY_COLOR_RENDERIN
G
VALUE_COLOR_RENDER_QU
ALITY
Select quality or speed
for color rendering.
VALUE_COLOR_RENDER_SP
EED
VALUE_COLOR_RENDER_DE
FAULT
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
19
4.10 Readers and Writers for Images

To load an image, use the static read method of the ImageIO class:

File f = . . .;
BufferedImage image = ImageIO.read(f);

The ImageIO class picks an appropriate reader, based on the file type. It may
consult the file extension and the "magic number" at the beginning of the file
for that purpose. If no suitable reader can be found or the reader can't decode
the file contents, then the read method returns null.

Writing an image to a file is just as simple:

File f = . . .;
String format = . . .;
ImageIO.write(image, format, f);

Here the format string is a string identifying the image format, such as "JPEG"
or "PNG".
The ImageIO class picks an appropriate writer and saves the file.

Obtaining Readers and Writers for Image File Types

For more advanced image reading and writing operations that go beyond the
static read and write methods of the ImageIO class, you first need to get the
appropriate ImageReader and ImageWriter objects. The ImageIO class
enumerates readers and writers that match one of the following:
an image format (such as "JPEG")
a file suffix (such as "jpg")
a MIME type (such as "image/jpeg")

For example, you can obtain a reader that reads JPEG files as follows:

ImageReader reader = null;
Iterator iter = ImageIO.getImageReadersByFormatName("JPEG");
if (iter.hasNext) reader = (ImageReader)iter.next();

The getImageReadersBySuffix and getImageReadersByMIMEType method
enumerate readers that match a file extension or MIME type.

Reading and Writing Files with Multiple Images

Some files, in particular, animated GIF files, contain multiple images. The read
method of the ImageIO class reads a single image. To read multiple images,
turn the input source (for example, an input stream or file) into an
ImageInputStream.
InputStream in = . . .;
ImageInputStream imageIn = ImageIO.createImageInputStream(in);
Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
20
Then attach the image input stream to the reader:

reader.setInput(imageIn, true);

The second parameter indicates that the input is in "seek forward only" mode.
Otherwise, random access is used, either by buffering stream input as it is
read, or by using random file access.

4.12 Image Manipulation

4.13 Printing

JDK 1.1 introduced very lightweight printing support, just enough to produce
simple printouts, as long as u were not too particular about the print quality.
JDK 1.2 introduced the beginnings of a robust printing model that is fully
integrated with 2D graphics. JDK 1.3 provided minor improvements. JDK 1.4
adds important enhancements such as discovery of printer features.

Graphics Printing
To print a 2D graphic, the graphic can contain text in various fonts .To
generate a printout, u take care of these two tasks:
a) Supply an object that implements the Printable interface.
b) Start a print job.

The printable interface has a single method:

int print(Graphics g,PageFormat format, int page)

This method is called whenever the print engine needs to have a page
formatted for printing. Your code draws the text & image that are to be printed
onto the graphics context. The page format tells u the paper size & the print
margins. The page number tells u which page to render.

To start a print job, u use the PrinterJob class. Firstly u call the
getPrinterJob method to get a print job object. Then set the Printable object
that u want to print.

Printable canvas=;
PrinterJob job = PrinterJob.getPrinterJob();

Job.setPrintable(canvas);

Before starting the print job, u should call the printDialog method to display a
print dialog box. That dialog box gives the user a chance to select the printer to
be used(in case multiple printers are available), the page range that should be
printed & various printer settings.
U collect printer settings in an object of a class that implements the
PrintRequestAttributeSet interface to the printDialog method.
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
21
The JDK provides a HashRequestAttributeSet class for that purpose.
HashPrintRequestAttributeSet attributes= new
HashPrintRequestAttributeSet();

Add attribute settings & pass the attributes object to the printDialog method.
The printDialog method returns true if the userclicked OK & false if the user
canceled the dialog box.
If the user accepted, call the print method of the PrinterJob class to start the
printing process. The print method may throw a PrinterException.
The page Format parameter of the print method contains information about
the printed page.
The methods getWidth & getHeight of the pageFormat class gives u the
complete paper size.
getWidth & getHeight return the paper size. Measured in points.
One point is 1/72 of an inch.
Default unit for all print graphics contexts is one point.

Multiple-Page Printing -

In practice, you usually shouldn't pass a raw Printable object to a print job.
Instead, you should obtain an object of a class that implements the Pageable
interface. TheJava platform supplies one such class, called Book.A book is
made up of sections, each of which is a Printable object. You make a book by
adding Printab1e objects and their page counts.

Book book =new Book () ;
Printable coverpage = . . .;
Printab1e bodypages= . . .;
book.append(coverPage, pageFormat); / / append 1 page
book.append(bodyPages, pageFormat, pageCount);

Then, you use thesetpageable method to pass the Bookobject to the print job.
printJob,setPageable(book) ;
Now the print job knows exactly how many pages to print.Then, the print
dialog box displays an accurate page range, and the user can select the entire
range or subranges.
Your Printable class needs a layout algorithm that computes the layout of the
material on the printed pages.

Print Servfces -


The API defines a number of data types and lets you find print services that are
able to print them. Among the data types:
Images in GIF,JPEG, or PNG format.
Documents in text, HTML, PostScript, or PDF format .
Raw printer code data .
Objects of a class that implements Printable, Pageable,or RenderableImage

Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
22
The data themselves can be stored in a source of bytes or characters such as
an input stream, a URL, or an array. A documentflavor describes the
combination of a data source and a data type. The DocFlavor class defines a
number of inner classes for the various data sources. Each of the inner classes
defines constants to specify the flavors. For example, the
constant
DocFlavor .INPULSTREAM. GIF
describes a GIF image that is read from an input stream.

Stream Print Services -
A print service sends print data to a printer. A stream print service generates
the same print data but instead sends them to a stream, perhaps for delayed
printing or because the print data format can be interpreted by other
programs. In particular, if the print data format is PostScript, then it is useful
to save the print data to a file because many programs can process
PostScript files.
Enumerating stream print services is a bit more tedious than locating regular
print services.
You need both the DocFlavor of the object to be printed and the MIME type of
the stream output. You then get a StreamPrintServiceFactory array of factories.
DocFlavorflavor =DocFlavor. SERVICEJORMATTED. PRINTABLE;
String mimeType = "application/postscript";
StreamPrintServiceFactory[ ]factories = StreamPrintServiceFactory.
lookupStreamPrintServiceFactories( flavor, mimeType) ;

Printing Attributes -

There are four important groups of attributes. The first two specify
requests to the printer.
Print request attributes- request particular features for all doc objects in a
print job, such as two-sided printing or the paper size.
Doc attributes are request attributes that apply only to a single doc object.
The other two attributes contain information about the printer and job status.

Print service attributes give information about the print service, such as the
printer make and model or whether the printer is currently accepting
jobs.
Print job attributes give information about the status of a particular print
job, such as whether the job is already completed.

For example, objects of the Copies class describe the number of copies of a
printout. That class implements both the PrintRequestAttributeand the
PrintJobAttribute interfaces. A print request may contain a request for multiple
copies.The SupportedValuesAttributeinterface indicates that an attribute value
does not reflect actual request or status data but rather the capability of a
service. For example,the CopiesSupported class implements the
SupportedValuesAttributeinterface.
A superinterface, AttributeSet, has four subinterfaces:
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
23
PrintRequestAttributeSet
DocAttributeSet
PrintServiceAttributeSet
PrintJobAttributeSet

Each of these interfaces has an implementing class, yielding the five classes:
HashAttributeSet
HashPrintRequestAttributeSet
HashDocAttributeSet
HashPrintServiceAttributeSet
HashPrintJobAttributeSet

4.14 Clipboard

One of the most useful and convenient user interface mechanisms of graphical
user interface environments (such as Windows and the X Window System) is
cut and paste. You select some data in one program and cut or copy it to the
clipboard. Then, you select another program and paste the clipboard contents
into that application. Using the clipboard, you can transfer text, images, or
other data from one document to another, or, of course, from one place in a
document to another place in the same document. Cut and paste is so natural
that most computer users never think about it.

However, in SDK 1.0, there was no support for cut and paste. You could not
cut and paste between Java applications. For example, if you have a browser
written in the Java programming language, then you could not copy text and
images from a web page and transfer them into a word processor based on
Java technology. SDK 1.1 implemented a rudimentary clipboard mechanism.

That mechanism has been gradually improved and is now quite usable on a
number of platforms.

Even though the clipboard is conceptually simple, implementing clipboard
services is actually harder than you might think.

Often, programs need to support cut and paste of data types that the system
clipboard cannot handle. The data transfer API supports the transfer of
arbitrary local object references in the same virtual machine. Between different
virtual machines, you can transfer serialized objects and references to remote
objects.
Classes and Interfaces for Data Transfer

Data transfer in the Java technology is implemented in a package called
java.awt.datatransfer. Here is an overview of the most important classes and
interfaces of that package.

Objects that can be transferred via a clipboard must implement the
Transferable interface.
Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
24
The Clipboard class describes a clipboard. Transferable objects are the
only items that can be put on or taken off a clipboard. The system
clipboard is a concrete example of a Clipboard.
The DataFlavor class describes data flavors that can be placed on the
clipboard.
The StringSelection class is a concrete class that implements the
Transferable interface. It is used to transfer text strings.
A class must implement the ClipboardOwner interface if it wants to be
notified when the clipboard contents have been overwritten by someone
else. Clipboard ownership enables "delayed formatting" of complex data.

Transferring Text

The best way to get comfortable with the data transfer classes is to start with
the simplest situation: transferring text to and from the system clipboard. The
idea of the following program is simple. First, get a reference to the system
clipboard.

Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();

Transfer Format

Between a program in Java programming language and a native program Text,
images, file lists, (depending on the host platform) Between two cooperating
programs in the Java programming language Serialized and remote objects
Within one program in the Java programming language Any object For strings
to be transferred to the clipboard, they need to be wrapped into StringSelection
objects. The constructor takes the text you want to transfer.

String text = . . .
StringSelection selection = new StringSelection(text);

The actual transfer is done by a call to setContents, which takes a
StringSelection object and a ClipBoardOwner as parameters. If you are not
interested in designating a clipboard owner, set the second parameter to null.

clipboard.setContents(selection, null);

Program
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.awt.datatransfer.*;
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
25

public class GetClipboard {
public static void main(String args[]) {
JFrame frame = new JFrame("Use Clipboard");
final Clipboard clipboard =
frame.getToolkit().getSystemClipboard();
final JTextArea area = new JTextArea();
frame.add(area, BorderLayout.CENTER);
JButton copy = new JButton("Copy");
copy.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String selection = area.getSelectedText();
StringSelection data = new StringSelection(selection);
clipboard.setContents(data, data);
}
});
JButton paste = new JButton("Paste");
paste.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent actionEvent) {
Transferable clipData = clipboard.getContents(clipboard);
try {
if(clipData.isDataFlavorSupported(DataFlavor.stringFlavor)) {
String s = (String)(clipData.getTransferData(DataFlavor.stringFlavor));
area.replaceSelection(s);
}
Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
26
} catch (Exception ufe) {}
}
});
JPanel p = new JPanel();
p.add(copy);
p.add(paste);
frame.add(p, BorderLayout.SOUTH);
frame.setSize(300, 200);
frame.setVisible(true);
}
}

4.15 Drag and Drop

When you use cut and paste to transmit information between two programs,
the clipboard acts as an intermediary. The drag and drop metaphor cuts out
the middleman and lets two programs communicate directly. The Java 2
platform offers basic support for drag and drop. You can carry out drag and
drop operations between Java applications and native applications.
You initiate a drag operation with a gesture inside a drag sourceusually, by
first selecting one or more elements and then dragging the selection away from
its initial location.
When you release the mouse button over a drop target that accepts the drop
operation, then the drop target queries the drag source for information about
the dropped elements, and it initiates some operation. For example, if you drop
a file icon from Windows Explorer to WordPad, then WordPad opens the file.

If you hold down the SHIFT or CTRL key while dragging, then the type of the
drop action changes from a move action to a copy action, and a copy of the file
is placed into the directory. If you hold down both SHIFT and CTRL keys, then
a link to the file is placed into the directory.

Thus, there are three types of drop actions with different gestures:
Move
Copy
Link
The intention of the link action is to establish a reference to the dropped
element. Such links typically require support from the host operating system
(such as symbolic links for files, or object linking for document components)
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
27
and don't usually make a lot of sense in cross platform programs. In this
section, we'll focus on using drag and drop for copying and moving.

You can designate any AWT component to be a drop target. To do so, you need
to construct a DropTarget object and pass the component and a drop target
listener to the constructor. The constructor registers the object with the drag
and drop system.

DropTarget target = new DropTarget(component, listener);

You can activate or deactivate the target with the setActive method. By default,
the target is active.

target.setActive(b);

You can call the setDefaultActions method to set the drop operations that you
want to accept by default. The operations are:

DndConstants.ACTION_COPY
DndConstants.ACTION_MOVE
DndConstants.ACTION_COPY_OR_MOVE
DndConstants.ACTION_LINK

By default, all operations are allowed.
Now you need to implement a drop target listener. The DropTargetListener
interface has five methods:

void dragEnter(DropTargetDragEvent event)
void dragExit(DropTargetEvent event)
void dragOver(DropTargetDragEvent event)
void dropActionChanged(DropTargetDragEvent event)
void drop(DropTargetDropEvent event)
The dragEnter and dragExit methods are called when the cursor enters or exits
the drop target component. In the dragEnter method, you have the chance to
set the cursor shape to indicate whether the drop target is willing to accept the
drop.

You don't usually worry about the dragExit method. However, if you built up
some elaborate mechanism for visual feedback, then you can dispose of it in
this method.

The dragOver method is called continuously as the user moves the mouse over
the drop target component. You can use it to give detailed visual feedback
about the effect of a drop.

For example, if the drop target is a tree component, you can highlight the node
under the cursor or even open up a subtree if the cursor hovers over a node.

Advanced Java
Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
28
The dropActionChanged method is called if the user changes the action
gesture. For example, if the user presses or lifts the SHIFT or CTRL keys while
moving the mouse over the drop target component, then this method is called.
That gives you a chance to modify the visual feedback and match it to the
changed action.

The most important method is the drop method. It is called when the user has
committed to a drop by finishing the drop gesture, usually by releasing the
mouse button. Note that this method is called whether or not you previously
indicated that you would accept the drop.

Program

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.TransferHandler;


public class DragAndDropExample extends JFrame {

JTextField field;
JButton button;

public DragAndDropExample() {

setTitle("Simple Drag & Drop");

setLayout(null);

button = new JButton("Button");
button.setBounds(200, 50, 90, 25);

field = new JTextField();
field.setBounds(30, 50, 150, 25);

add(button);
add(field);

field.setDragEnabled(true);
button.setTransferHandler(new TransferHandler("text"));

setSize(330, 150);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);
}

public static void main(String[] args) {
Advanced Java

Mohit Chowdhary, Poonam Chaudhary,
Assistant Prof Deptt of Computer Science
29
new DragAndDropExample();
}
}