Java AWT Canvas - W3spoint

Java AWT (Abstract Window Toolkit) is a set of APIs (Application Programming Interfaces) for developing graphical user interface (GUI) applications in Java. The Canvas class in Java AWT is a component that provides a blank rectangular area on the screen for drawing custom graphics.

To use the Canvas class, you first create an instance of the class and add it to a container, such as a Frame or a Panel. Then, you can use various methods of the Graphics class, which is provided by the Canvas, to draw shapes, images, and text on the canvas.

Here is an example of creating a Canvas and drawing a rectangle on it:

import java.awt.*;
import java.awt.event.*;

public class MyCanvas extends Canvas {
   public MyCanvas() {
      setBackground(Color.WHITE);
      setSize(300, 200);
   }
 
   public void paint(Graphics g) {
      g.setColor(Color.RED);
      g.fillRect(50, 50, 200, 100);
   }
 
   public static void main(String[] args) {
      Frame frame = new Frame("My Canvas");
      MyCanvas canvas = new MyCanvas();
      frame.add(canvas);
      frame.pack();
      frame.setVisible(true);
   }
}

In this example, the constructor of the MyCanvas class sets the background color and size of the canvas. The paint() method is called automatically whenever the canvas needs to be redrawn, and it draws a red rectangle using the fillRect() method of the Graphics class.

The main() method creates a Frame, adds the MyCanvas instance to it, packs the frame to fit the size of the canvas, and makes it visible.

Note that the AWT Canvas class is an older technology, and newer GUI frameworks like Swing and JavaFX are now recommended for developing GUI applications in Java.

AWT Canvas class Declaration:

To declare a Canvas class in Java AWT, you would use the following syntax:

public class MyCanvas extends Canvas {
    // class code
}

In this example, the name of the class is “MyCanvas”, and it extends the Canvas class, which means it inherits all the methods and properties of the Canvas class.

You can then add your own methods and properties to the MyCanvas class as needed to customize the behavior and appearance of the canvas. The paint() method, which is called automatically when the canvas needs to be redrawn, can also be overridden to draw custom graphics on the canvas.

Canvas Class Constructors:

The Canvas class in Java AWT has two constructors that you can use to create a new instance of the class:

Canvas(): This constructor creates a new canvas with a default size of 0 pixels by 0 pixels.
Canvas(GraphicsConfiguration gc): This constructor creates a new canvas with the specified graphics configuration. The graphics configuration specifies the characteristics of the graphics hardware and software used to display the canvas, such as the color depth and resolution.

In addition to these constructors, you can also create a custom constructor in your subclass of Canvas to initialize any additional properties or set a specific size for the canvas:

public class MyCanvas extends Canvas {
    public MyCanvas(int width, int height) {
        setSize(width, height);
    }
}

In this example, the custom constructor takes two arguments for the width and height of the canvas, and sets the size of the canvas using the setSize() method. This allows you to create a canvas with a specific size when you instantiate the MyCanvas class, like this:

MyCanvas canvas = new MyCanvas(300, 200);

3 / 3

The Canvas class in Java AWT provides several methods that you can use to interact with the canvas and its contents:

void paint(Graphics g): This method is called automatically when the canvas needs to be redrawn. You can override this method in your subclass of Canvas to draw custom graphics on the canvas using the Graphics object that is passed as an argument.
void repaint(): This method requests that the canvas be repainted. The paint() method will be called automatically at some point in the future, depending on the system’s repaint scheduling algorithm.
void setSize(int width, int height): This method sets the size of the canvas to the specified width and height in pixels.
void setBackground(Color color): This method sets the background color of the canvas to the specified Color.
void setForeground(Color color): This method sets the foreground color of the canvas to the specified Color. This is the color that will be used for drawing shapes and text.
Graphics getGraphics(): This method returns a Graphics object that can be used to draw on the canvas.
Image createImage(int width, int height): This method creates a new, blank image with the specified width and height. You can then use the Graphics object of the canvas to draw on the image.
Dimension getSize(): This method returns the current size of the canvas as a Dimension object, which contains the width and height in pixels.
Color getBackground(): This method returns the current background color of the canvas as a Color object.
Color getForeground(): This method returns the current foreground color of the canvas as a Color object.
Toolkit getToolkit(): This method returns the Toolkit object for the current system, which can be used to access system resources like the mouse cursor and system clipboard.

These are some of the most commonly used methods of the Canvas class, but there are many others as well. You can find a complete list of methods in the Java documentation for the Canvas class.

Method Inherited by Canvas Class:

The Canvas class is a part of the Python Tkinter GUI toolkit, which provides a way to create graphical user interfaces. The Canvas class inherits several methods from its base class, the tkinter.Widget class. Here are some of the methods inherited by the Canvas class:

bind(sequence, function) – This method binds a function to an event, such as a mouse click or key press.
unbind(sequence, function) – This method unbinds a function from an event.
create_arc(x1, y1, x2, y2, options) – This method creates an arc on the canvas.
create_bitmap(x, y, options) – This method creates a bitmap on the canvas.
create_image(x, y, options) – This method creates an image on the canvas.
create_line(x1, y1, x2, y2, …, options) – This method creates a line on the canvas.
create_oval(x1, y1, x2, y2, options) – This method creates an oval on the canvas.
create_polygon(x1, y1, x2, y2, …, options) – This method creates a polygon on the canvas.
create_rectangle(x1, y1, x2, y2, options) – This method creates a rectangle on the canvas.
create_text(x, y, options) – This method creates text on the canvas.
delete(tagOrId) – This method deletes an item or group of items from the canvas.
find_closest(x, y, halo=None, start=None, end=None) – This method finds the item closest to the specified point.
find_enclosed(x1, y1, x2, y2) – This method finds all items that are entirely enclosed by the specified rectangle.
find_overlapping(x1, y1, x2, y2) – This method finds all items that overlap the specified rectangle.
itemconfig(tagOrId, **options) – This method configures the options for an item or group of items.
lower(tagOrId, belowThis=None) – This method lowers an item or group of items to the bottom of the display order.
raise_(tagOrId, aboveThis=None) – This method raises an item or group of items to the top of the display order.

These methods, along with others inherited from the tkinter.Widget class, allow the Canvas class to create and manipulate a wide variety of graphical elements.

Java AWT Canvas Example:

Sure, here’s an example of how to use the Java AWT Canvas class:

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class CanvasExample extends Canvas {
   public CanvasExample() {
      setBackground(Color.WHITE);
   }
 
   public void paint(Graphics g) {
      g.setColor(Color.RED);
      g.fillOval(100, 100, 50, 50);
   }
 
   public static void main(String[] args) {
      Frame frame = new Frame("Canvas Example");
      Canvas canvas = new CanvasExample();
      canvas.setSize(300, 200);
      frame.add(canvas);
      frame.pack();
      frame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      frame.setVisible(true);
   }
}

This code creates a simple red circle on a white background using the Canvas class. The CanvasExample class extends the Canvas class and sets the background color to white in its constructor. The paint method is overridden to draw a red circle using the Graphics object provided by the canvas.

In the main method, a new Frame is created with the title “Canvas Example”. A new instance of CanvasExample is created and added to the Frame. The size of the canvas is set to 300 x 200, and the Frame is packed to fit the size of the canvas. A WindowListener is added to the Frame to handle the window close event. Finally, the Frame is made visible.

When you run this code, you should see a window with a red circle on a white background.