Source for gnu.java.awt.peer.GLightweightPeer

   1: /* GLightweightPeer.java --
   2:    Copyright (C) 2003, 2004 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package gnu.java.awt.peer;
  40: 
  41: import java.awt.AWTEvent;
  42: import java.awt.AWTException;
  43: import java.awt.BufferCapabilities;
  44: import java.awt.Color;
  45: import java.awt.Component;
  46: import java.awt.Cursor;
  47: import java.awt.Dimension;
  48: import java.awt.Font;
  49: import java.awt.FontMetrics;
  50: import java.awt.Graphics;
  51: import java.awt.GraphicsConfiguration;
  52: import java.awt.Image;
  53: import java.awt.Insets;
  54: import java.awt.Point;
  55: import java.awt.Rectangle;
  56: import java.awt.Toolkit;
  57: import java.awt.event.PaintEvent;
  58: import java.awt.image.ColorModel;
  59: import java.awt.image.ImageObserver;
  60: import java.awt.image.ImageProducer;
  61: import java.awt.image.VolatileImage;
  62: import java.awt.peer.ContainerPeer;
  63: import java.awt.peer.LightweightPeer;
  64: 
  65: /*
  66:  * Another possible implementation strategy for lightweight peers is
  67:  * to make GLightweightPeer a placeholder class that implements
  68:  * LightweightPeer.  Then the Component and Container classes could
  69:  * identify a peer as lightweight and handle it specially.  The
  70:  * current approach is probably more clear but less efficient.
  71:  */
  72: 
  73: /**
  74:  * A stub class that implements the ComponentPeer and ContainerPeer
  75:  * interfaces using callbacks into the Component and Container
  76:  * classes.  GLightweightPeer allows the Component and Container
  77:  * classes to treat lightweight and heavyweight peers in the same way.
  78:  *
  79:  * Lightweight components are painted directly onto their parent
  80:  * containers through an Image object provided by the toolkit.
  81:  */
  82: public class GLightweightPeer
  83:   implements LightweightPeer, ContainerPeer
  84: {
  85:   private Component comp;
  86: 
  87:   private Insets containerInsets;
  88: 
  89:   public GLightweightPeer(Component comp)
  90:   {
  91:     this.comp = comp;
  92:   }
  93: 
  94:   // -------- java.awt.peer.ContainerPeer implementation:
  95:   
  96:   public Insets insets()
  97:   {
  98:     return getInsets ();
  99:   }
 100:   
 101:   public Insets getInsets()
 102:   {
 103:     if (containerInsets == null)
 104:       containerInsets = new Insets (0,0,0,0);
 105:     return containerInsets;
 106:   }
 107:   
 108:   public void beginValidate()
 109:   {
 110:   }
 111:   
 112:   public void endValidate()
 113:   {
 114:   }
 115:   
 116:   public void beginLayout()
 117:   {
 118:   }
 119:   
 120:   public void endLayout()
 121:   {
 122:   }
 123:   
 124:   public boolean isPaintPending()
 125:   {
 126:     return false;
 127:   }
 128: 
 129:   // -------- java.awt.peer.ComponentPeer implementation:
 130: 
 131:   public int checkImage(Image img, int width, int height, ImageObserver o)
 132:   {
 133:     return comp.getToolkit().checkImage(img, width, height, o);
 134:   }
 135: 
 136:   public Image createImage(ImageProducer prod)
 137:   {
 138:     return comp.getToolkit().createImage(prod);
 139:   }
 140: 
 141:   /* This method is not called. */
 142:   public Image createImage(int width, int height)
 143:   {
 144:     return null;
 145:   }
 146: 
 147:   public void disable() {}
 148: 
 149:   public void dispose() {}
 150: 
 151:   public void enable() {}
 152: 
 153:   public GraphicsConfiguration getGraphicsConfiguration()
 154:   {
 155:     return null;
 156:   }
 157: 
 158:   public FontMetrics getFontMetrics(Font f)
 159:   {
 160:     return comp.getToolkit().getFontMetrics(f);
 161:   }
 162: 
 163:   /* Returning null here tells the Component object that called us to
 164:    * use its parent's Graphics. */
 165:   public Graphics getGraphics()
 166:   {
 167:     return null;
 168:   }
 169: 
 170:   public Point getLocationOnScreen()
 171:   {
 172:     Point parentLocation = comp.getParent().getLocationOnScreen();
 173:     return new Point (parentLocation.x + comp.getX(),
 174:                       parentLocation.y + comp.getY());
 175:   }
 176: 
 177:   public Dimension getMinimumSize()
 178:   {
 179:     return new Dimension(comp.getWidth(), comp.getHeight());
 180:   }
 181: 
 182:   /* A lightweight component's preferred size is equivalent to its
 183:    * Component width and height values. */
 184:   public Dimension getPreferredSize()
 185:   {
 186:     return new Dimension(comp.getWidth(), comp.getHeight());
 187:   }
 188: 
 189:   /* Returning null here tells the Component object that called us to
 190:    * use its parent's Toolkit. */
 191:   public Toolkit getToolkit()
 192:   {
 193:     return null;
 194:   }
 195: 
 196:   public void handleEvent(AWTEvent e) {}
 197: 
 198:   public void hide() {}
 199: 
 200:   public boolean isFocusable() 
 201:   {
 202:     return false;
 203:   }
 204: 
 205:   public boolean isFocusTraversable()
 206:   {
 207:     return false;
 208:   }
 209: 
 210:   public Dimension minimumSize()
 211:   {
 212:     return getMinimumSize();
 213:   }
 214: 
 215:   public Dimension preferredSize()
 216:   {
 217:     return getPreferredSize();
 218:   }
 219: 
 220:   public void paint(Graphics graphics) {}
 221: 
 222:   public boolean prepareImage(Image img, int width, int height,
 223:                   ImageObserver o)
 224:   {
 225:     return comp.getToolkit().prepareImage(img, width, height, o);
 226:   }
 227: 
 228:   public void print(Graphics graphics) {}
 229: 
 230:   public void repaint(long tm, int x, int y, int width, int height)
 231:   {
 232:     Component p = comp.getParent ();
 233:     if(p != null)
 234:       p.repaint(tm,x+comp.getX(),y+comp.getY(),width,height);
 235:   }
 236: 
 237:   public void requestFocus() {}
 238: 
 239:   public boolean requestFocus(Component source, boolean bool1, boolean bool2, long x)
 240:   {
 241:     return false;
 242:   }
 243: 
 244:   public void reshape(int x, int y, int width, int height) {}
 245: 
 246:   public void setBackground(Color color) {}
 247: 
 248:   public void setBounds(int x, int y, int width, int height) {}
 249: 
 250:   public void setCursor(Cursor cursor) {}
 251: 
 252:   public void setEnabled(boolean enabled) {}
 253: 
 254:   public void setEventMask(long eventMask) {}
 255: 
 256:   public void setFont(Font font) {}
 257: 
 258:   public void setForeground(Color color) {}
 259: 
 260:   public void setVisible(boolean visible) {}
 261: 
 262:   public void show() {}
 263: 
 264:   public ColorModel getColorModel ()
 265:   {
 266:     return comp.getColorModel ();
 267:   }
 268: 
 269:   public boolean isObscured()
 270:   {
 271:     return false;
 272:   }
 273: 
 274:   public boolean canDetermineObscurity()
 275:   {
 276:     return false;
 277:   }
 278: 
 279:   public void coalescePaintEvent(PaintEvent e) { }
 280: 
 281:   public void updateCursorImmediately() { }
 282: 
 283:   public VolatileImage createVolatileImage(int width, int height) 
 284:   { 
 285:     return null; 
 286:   }
 287: 
 288:   public boolean handlesWheelScrolling()
 289:   {
 290:     return false;
 291:   }
 292: 
 293:   public void createBuffers(int x, BufferCapabilities capabilities) 
 294:     throws AWTException { }
 295: 
 296:   public Image getBackBuffer()
 297:   {
 298:     return null;
 299:   }
 300: 
 301:   public void flip(BufferCapabilities.FlipContents contents) { }
 302: 
 303:   public void destroyBuffers() { }
 304: 
 305:   public boolean isRestackSupported()
 306:   {
 307:     return false;
 308:   }
 309: 
 310:   public void cancelPendingPaint(int x, int y, int width, int height)
 311:   {
 312:     
 313:   }
 314: 
 315:   public void restack()
 316:   {
 317:     
 318:   }
 319: 
 320:   public Rectangle getBounds()
 321:   {
 322:     return null;
 323:   }
 324: 
 325:   public void reparent(ContainerPeer parent)
 326:   {
 327:     
 328:   }
 329: 
 330:   public void setBounds(int x, int y, int z, int width, int height)
 331:   {
 332:     
 333:   }
 334: 
 335:   public boolean isReparentSupported()
 336:   {
 337:     return false;
 338:   }
 339: 
 340:   public void layout()
 341:   {
 342:     
 343:   }
 344: }