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
/* * @(#)Canvas.java 1.39 06/04/07 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.awt; import java.awt.image.BufferStrategy; import java.awt.peer.CanvasPeer; import javax.accessibility.*; /** * A <code>Canvas</code> component represents a blank rectangular * area of the screen onto which the application can draw or from * which the application can trap input events from the user. * <p> * An application must subclass the <code>Canvas</code> class in * order to get useful functionality such as creating a custom * component. The <code>paint</code> method must be overridden * in order to perform custom graphics on the canvas. * * @version 1.39 04/07/06 * @author Sami Shaio * @since JDK1.0 */ public class Canvas extends Component implements Accessible { private static final String base = "canvas"; private static int nameCounter = 0; /* * JDK 1.1 serialVersionUID */ private static final long serialVersionUID = -2284879212465893870L; /** * Constructs a new Canvas. */ public Canvas() { } /** * Constructs a new Canvas given a GraphicsConfiguration object. * * @param config a reference to a GraphicsConfiguration object. * * @see GraphicsConfiguration */ public Canvas(GraphicsConfiguration config) { this(); graphicsConfig = config; } /** * Construct a name for this component. Called by getName() when the * name is null. */ String constructComponentName() { synchronized (getClass()) { return base + nameCounter++; } } /** * Creates the peer of the canvas. This peer allows you to change the * user interface of the canvas without changing its functionality. * @see java.awt.Toolkit#createCanvas(java.awt.Canvas) * @see java.awt.Component#getToolkit() */ public void addNotify() { synchronized (getTreeLock()) { if (peer == null) peer = getToolkit().createCanvas(this); super.addNotify(); } } /** * Paints this canvas. * <p> * Most applications that subclass <code>Canvas</code> should * override this method in order to perform some useful operation * (typically, custom painting of the canvas). * The default operation is simply to clear the canvas. * Applications that override this method need not call * super.paint(g). * * @param g the specified Graphics context * @see #update(Graphics) * @see Component#paint(Graphics) */ public void paint(Graphics g) { g.clearRect(0, 0, width, height); } /** * Updates this canvas. * <p> * This method is called in response to a call to <code>repaint</code>. * The canvas is first cleared by filling it with the background * color, and then completely redrawn by calling this canvas's * <code>paint</code> method. * Note: applications that override this method should either call * super.update(g) or incorporate the functionality described * above into their own code. * * @param g the specified Graphics context * @see #paint(Graphics) * @see Component#update(Graphics) */ public void update(Graphics g) { g.clearRect(0, 0, width, height); paint(g); } boolean postsOldMouseEvents() { return true; } /** * Creates a new strategy for multi-buffering on this component. * Multi-buffering is useful for rendering performance. This method * attempts to create the best strategy available with the number of * buffers supplied. It will always create a <code>BufferStrategy</code> * with that number of buffers. * A page-flipping strategy is attempted first, then a blitting strategy * using accelerated buffers. Finally, an unaccelerated blitting * strategy is used. * <p> * Each time this method is called, * the existing buffer strategy for this component is discarded. * @param numBuffers number of buffers to create, including the front buffer * @exception IllegalArgumentException if numBuffers is less than 1. * @exception IllegalStateException if the component is not displayable * @see #isDisplayable * @see #getBufferStrategy * @since 1.4 */ public void createBufferStrategy(int numBuffers) { super.createBufferStrategy(numBuffers); } /** * Creates a new strategy for multi-buffering on this component with the * required buffer capabilities. This is useful, for example, if only * accelerated memory or page flipping is desired (as specified by the * buffer capabilities). * <p> * Each time this method * is called, the existing buffer strategy for this component is discarded. * @param numBuffers number of buffers to create * @param caps the required capabilities for creating the buffer strategy; * cannot be <code>null</code> * @exception AWTException if the capabilities supplied could not be * supported or met; this may happen, for example, if there is not enough * accelerated memory currently available, or if page flipping is specified * but not possible. * @exception IllegalArgumentException if numBuffers is less than 1, or if * caps is <code>null</code> * @see #getBufferStrategy * @since 1.4 */ public void createBufferStrategy(int numBuffers, BufferCapabilities caps) throws AWTException { super.createBufferStrategy(numBuffers, caps); } /** * Returns the <code>BufferStrategy</code> used by this component. This * method will return null if a <code>BufferStrategy</code> has not yet * been created or has been disposed. * * @return the buffer strategy used by this component * @see #createBufferStrategy * @since 1.4 */ public BufferStrategy getBufferStrategy() { return super.getBufferStrategy(); } /* * --- Accessibility Support --- * */ /** * Gets the AccessibleContext associated with this Canvas. * For canvases, the AccessibleContext takes the form of an * AccessibleAWTCanvas. * A new AccessibleAWTCanvas instance is created if necessary. * * @return an AccessibleAWTCanvas that serves as the * AccessibleContext of this Canvas * @since 1.3 */ public AccessibleContext getAccessibleContext() { if (accessibleContext == null) { accessibleContext = new AccessibleAWTCanvas(); } return accessibleContext; } /** * This class implements accessibility support for the * <code>Canvas</code> class. It provides an implementation of the * Java Accessibility API appropriate to canvas user-interface elements. * @since 1.3 */ protected class AccessibleAWTCanvas extends AccessibleAWTComponent { private static final long serialVersionUID = -6325592262103146699L; /** * Get the role of this object. * * @return an instance of AccessibleRole describing the role of the * object * @see AccessibleRole */ public AccessibleRole getAccessibleRole() { return AccessibleRole.CANVAS; } } // inner class AccessibleAWTCanvas }