Rotate Text in Java
In this section, you will study how to draw the rotated text in Java using
SWT.
In SWT, we have used the package org.eclipse.draw2D.Graphics to draw
the figure on to the surface. The interface IFigure allows to create the
complex Graphics and the Figure class implements the Graphical figures.
The SWT provides all the drawing capabilities to the class GC of the
package org.eclipse.draw2D.Graphics. The object of this class is used to
draw an image or any figure. This class provides different methods either to
draw or to fill the figure.
To draw the text, we have used the class Font of package java.awt.*
which sets the font. The method setColor() of class java.awt.Color
sets the color.
Following code draws the rotated text:
int angle = 12;
for (int i = 0; i < angle; i++) {
g2d.drawString("HelloWorld", 20, 0);
g2d.rotate(-2 * Math.PI / angle);
} |
To allow the figure to be hosted on the canvas, we have used the class LightweightSystem.
The method setContents() sets the contents of the LightweightSystem to the
figure. The class PaletteData describes the color data used by an
image. The method setClip()
sets the clip region and returns that rectangle. The method getClipping()
of class GC returns the bounding rectangle. The description of an image
is provided by the class ImageData.
Here is the code of RotateText.java
import java.awt.*;
import org.eclipse.draw2d.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.graphics.*;
import java.awt.image.BufferedImage;
import org.eclipse.draw2d.geometry.Dimension;
public class RotateText {
public static void main(String[] args) {
final ImageRenderer renderer = new ImageRenderer();
Shell shell = new Shell();
shell.setSize(300, 300);
shell.open();
shell.setText("rotate text");
LightweightSystem lightweightSystem = new LightweightSystem(shell);
IFigure figure = new Figure() {
public void paint(org.eclipse.draw2d.Graphics g) {
Dimension dim = getSize();
renderer.createRendering(g);
Graphics2D g2d = renderer.getGraphics2D();
g2d.setPaint(java.awt.Color.cyan);
g2d.fillRect(0, 0, dim.width, dim.width);
g2d.setFont
(new java.awt.Font("Arial Narrow", java.awt.Font.BOLD,15));
g2d.setColor(java.awt.Color.red);
g2d.translate(dim.width / 2, dim.width / 2);
int angle = 12;
for (int i = 0; i < angle; i++) {
g2d.drawString("HelloWorld", 20, 0);
g2d.rotate(-2 * Math.PI / angle);
}
renderer.render(g);
}
};
lightweightSystem.setContents(figure);
Display display = Display.getDefault();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
}
}
class ImageRenderer {
PaletteData paletteData = new PaletteData(0xFF0000,0xFF00, 0xFF);
java.awt.image.BufferedImage bufferedImage;
org.eclipse.swt.graphics.Image image;
ImageData imageData;
int[] pixels;
// allows to render on a Draw2D Graphics.
public void createRendering(org.eclipse.draw2d.Graphics g) {
org.eclipse.draw2d.geometry.Rectangle rect = g
.getClip(new org.eclipse.draw2d.geometry.Rectangle());
createRendering(rect.x, rect.y, rect.width, rect.height);
}
// create an image and allows rendering of the rectangular area.
private void createRendering(int X, int Y, int W, int H) {
checkImages(W, H);
java.awt.Graphics awtGraphics = bufferedImage.getGraphics();
awtGraphics.fillRect(X, Y, W, H);
}
public Graphics2D getGraphics2D() {
if (bufferedImage == null)
return null;
return (Graphics2D) bufferedImage.getGraphics();
}
public void render(GC gc) {
if (bufferedImage == null)
return;
org.eclipse.swt.graphics.Rectangle rect = gc.getClipping();
transfer(rect.x, rect.y, rect.width, rect.height);
gc.drawImage(image, rect.x, rect.y, rect.width, rect.height, rect.x,
rect.y, rect.width, rect.height);
}
public void render(org.eclipse.draw2d.Graphics graphics) {
if (bufferedImage == null)
return;
org.eclipse.draw2d.geometry.Rectangle rect = graphics
.getClip(new org.eclipse.draw2d.geometry.Rectangle());
transfer(rect.x, rect.y, rect.width, rect.height);
graphics.drawImage(image, rect.x, rect.y, rect.width, rect.height,
rect.x, rect.y, rect.width, rect.height);
}
// Transfers the region from the AWT image to the SWT image.
private void transfer(int X, int Y, int W, int H) {
int step = imageData.depth / 8;
byte[] data = imageData.data;
bufferedImage.getRGB(X, Y, W, H, pixels, 0, W);
for (int i = 0; i < H; i++) {
int idx = (Y + i) * imageData.bytesPerLine + X * step;
for (int j = 0; j < W; j++) {
int rgb = pixels[j + i * W];
for (int k = imageData.depth - 8; k >= 0; k -= 8) {
data[idx++] = (byte) ((rgb >> k) & 0xFF);
}
}
}
image = new
org.eclipse.swt.graphics.Image(Display.getDefault(),imageData);
}
// Initialize the image.
private void checkImages(int width, int height) {
int imageWidth = 0;
int imageHeight = 0;
if (image != null) {
imageWidth = image.getImageData().width;
imageHeight = image.getImageData().height;
}
if (width > imageWidth || height > imageHeight) {
width = Math.max(width, imageWidth);
height = Math.max(height, imageHeight);
bufferedImage = new BufferedImage(width, height,
BufferedImage.TYPE_INT_ARGB);
imageData = new ImageData(width, height, 24, paletteData);
pixels = new int[width * height];
}
}
}
|
Output will be displayed as:
Download Source Code:
