libjava/classpath/gnu/java/awt/peer/swing/SwingContainerPeer.java

   1 /* SwingContainerPeer.java -- A Swing based peer for AWT containers
   2    Copyright (C)  2006, 2007  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 package gnu.java.awt.peer.swing;
  39
  40 import gnu.classpath.SystemProperties;
  41
  42 import java.awt.Component;
  43 import java.awt.Container;
  44 import java.awt.Graphics;
  45 import java.awt.Image;
  46 import java.awt.Insets;
  47 import java.awt.Rectangle;
  48 import java.awt.event.KeyEvent;
  49 import java.awt.event.MouseEvent;
  50 import java.awt.peer.ComponentPeer;
  51 import java.awt.peer.ContainerPeer;
  52 import java.util.Iterator;
  53 import java.util.LinkedList;
  54
  55 /**
  56  * A peer for Container to be used with the Swing based AWT peers.
  57  *
  58  * @author Roman Kennke (kennke@aicas.com)
  59  */
  60 public class SwingContainerPeer
  61   extends SwingComponentPeer
  62   implements ContainerPeer
  63 {
  64
  65   /**
  66    * Stores all heavyweight descendents of the container. This is used
  67    * in {@link #peerPaintChildren(Graphics)}.
  68    */
  69   private LinkedList heavyweightDescendents;
  70
  71   /**
  72    * The backbuffer used for painting UPDATE events.
  73    */
  74   private Image backbuffer;
  75
  76   /**
  77    * Creates a new SwingContainerPeer.
  78    *
  79    * @param awtCont
  80    */
  81   public SwingContainerPeer(Container awtCont)
  82   {
  83     heavyweightDescendents = new LinkedList();
  84   }
  85
  86   /**
  87    * Registers a heavyweight descendent. This is then painted by
  88    * {@link #peerPaintChildren(Graphics)}.
  89    *
  90    * @param comp the descendent to register
  91    *
  92    * @see #peerPaintChildren(Graphics)
  93    * @see #removeHeavyweightDescendent(Component)
  94    */
  95   protected synchronized void addHeavyweightDescendent(Component comp)
  96   {
  97     heavyweightDescendents.add(comp);
  98     focusOwner = null;
  99   }
 100
 101   /**
 102    * Unregisters a heavyweight descendent.
 103    *
 104    * @param comp the descendent to unregister
 105    *
 106    * @see #peerPaintChildren(Graphics)
 107    * @see #addHeavyweightDescendent(Component)
 108    */
 109   protected synchronized void removeHeavyweightDescendent(Component comp)
 110   {
 111     heavyweightDescendents.remove(comp);
 112     focusOwner = null;
 113   }
 114
 115   /**
 116    * Returns an array of all registered heavyweight descendents.
 117    *
 118    * @return all registered heavyweight descendents
 119    */
 120   protected Component[] getHeavyweightDescendents()
 121   {
 122     Component[] heavyweights = new Component[heavyweightDescendents.size()];
 123     heavyweights = (Component[]) heavyweightDescendents.toArray(heavyweights);
 124     return heavyweights;
 125   }
 126
 127   /**
 128    * Returns the insets of the container.
 129    *
 130    * This is implemented to return the insets of the Swing container.
 131    *
 132    * @return the insets of the container
 133    */
 134   public Insets insets()
 135   {
 136     Insets retVal;
 137     if (swingComponent != null)
 138       retVal = swingComponent.getJComponent().getInsets();
 139     else
 140       retVal = new Insets(0, 0, 0, 0);
 141     return retVal;
 142   }
 143
 144   /**
 145    * Returns the insets of the container.
 146    *
 147    * This is implemented to return the insets of the Swing container.
 148    *
 149    * @return the insets of the container
 150    */
 151   public Insets getInsets()
 152   {
 153     return insets();
 154   }
 155
 156   /**
 157    * Called before the validation of this containers begins.
 158    */
 159   public void beginValidate()
 160   {
 161     // Nothing to do here.
 162   }
 163
 164   /**
 165    * Called after the validation of this containers ended.
 166    */
 167   public void endValidate()
 168   {
 169     // Nothing to do here.
 170   }
 171
 172   /**
 173    * Called before the layout of this containers begins.
 174    */
 175   public void beginLayout()
 176   {
 177     // Nothing to do here.
 178   }
 179
 180   /**
 181    * Called after the layout of this containers ended.
 182    */
 183   public void endLayout()
 184   {
 185     // Nothing to do here.
 186   }
 187
 188   /**
 189    * Returns <code>false</code> unconditionally. This method is not used at
 190    * the moment.
 191    *
 192    * @return <code>false</code>
 193    */
 194   public boolean isPaintPending()
 195   {
 196     return false;
 197   }
 198
 199   /**
 200    * Returns <code>false</code> unconditionally. This method is not used at
 201    * the moment.
 202    *
 203    * @return <code>false</code>
 204    */
 205   public boolean isRestackSupported()
 206   {
 207     return false;
 208   }
 209
 210   /**
 211    * This method is not used at the moment.
 212    */
 213   public void cancelPendingPaint(int x, int y, int width, int height)
 214   {
 215     // Nothing to do here.
 216   }
 217
 218   /**
 219    * This method is not used at the moment.
 220    */
 221   public void restack()
 222   {
 223     // Nothing to do here.
 224   }
 225
 226   /**
 227    * Performs the super behaviour (call peerPaintComponent() and
 228    * awtComponent.paint()), and forwards the paint request to the heavyweight
 229    * descendents of the container.
 230    */
 231   protected void peerPaint(Graphics g, boolean update)
 232   {
 233     if (isDoubleBuffering())
 234       {
 235         int width = awtComponent.getWidth();
 236         int height = awtComponent.getHeight();
 237         if (backbuffer == null
 238             || backbuffer.getWidth(awtComponent) < width
 239             || backbuffer.getHeight(awtComponent) < height)
 240           backbuffer = awtComponent.createImage(width, height);
 241         Graphics g2 = backbuffer.getGraphics();
 242         Rectangle clip = g.getClipRect();
 243         try
 244           {
 245             g2.setClip(clip);
 246             super.peerPaint(g2, update);
 247             peerPaintChildren(g2);
 248           }
 249         finally
 250           {
 251             g2.dispose();
 252           }
 253         g.drawImage(backbuffer, 0, 0, awtComponent);
 254       }
 255     else
 256       {
 257         super.peerPaint(g, update);
 258         peerPaintChildren(g);
 259       }
 260   }
 261
 262   /**
 263    * Determines if we should do double buffering or not.
 264    *
 265    * @return if we should do double buffering or not
 266    */
 267   private boolean isDoubleBuffering()
 268   {
 269     Object prop =
 270       SystemProperties.getProperty("gnu.awt.swing.doublebuffering", "false");
 271     return prop.equals("true");
 272   }
 273
 274   /**
 275    * Paints any heavyweight child components.
 276    *
 277    * @param g the graphics to use for painting
 278    */
 279   protected synchronized void peerPaintChildren(Graphics g)
 280   {
 281     // TODO: Is this the right painting order?
 282     for (Iterator i = heavyweightDescendents.iterator(); i.hasNext();)
 283       {
 284         Component child = (Component) i.next();
 285         ComponentPeer peer = child.getPeer();
 286
 287         if (peer instanceof SwingComponentPeer && child.isVisible())
 288           {
 289             // TODO: The translation here doesn't work for deeper
 290             // nested children. Fix this!
 291             Graphics g2 = g.create(child.getX(), child.getY(),
 292                                    child.getWidth(), child.getHeight());
 293             try
 294               {
 295                 // update() is only called for the topmost component if
 296                 // necessary, all other components only get paint() called.
 297                 ((SwingComponentPeer) peer).peerPaint(g2, false);
 298               }
 299             finally
 300               {
 301                 g2.dispose();
 302               }
 303           }
 304       }
 305   }
 306
 307   /**
 308    * Handles mouse events by dispatching it to the correct component.
 309    *
 310    * @param ev the mouse event
 311    */
 312   protected void handleMouseEvent(MouseEvent ev)
 313   {
 314     Component comp = awtComponent.getComponentAt(ev.getPoint());
 315     if(comp == null) comp = awtComponent;
 316     ComponentPeer peer = comp.getPeer();
 317     if (awtComponent != comp && !comp.isLightweight() && peer instanceof SwingComponentPeer)
 318       {
 319         ev.translatePoint(comp.getX(), comp.getY());
 320         ev.setSource(comp);
 321         ((SwingComponentPeer) peer).handleMouseEvent(ev);
 322       }
 323   }
 324
 325   /**
 326    * Handles mouse events by dispatching it to the correct component.
 327    *
 328    * @param ev the mouse event
 329    */
 330   protected void handleMouseMotionEvent(MouseEvent ev)
 331   {
 332     Component comp = awtComponent.getComponentAt(ev.getPoint());
 333     if (comp != null)
 334       {
 335         ComponentPeer peer = comp.getPeer();
 336         if (awtComponent != comp && !comp.isLightweight() && peer instanceof SwingComponentPeer)
 337           {
 338             ev.translatePoint(comp.getX(), comp.getY());
 339             ((SwingComponentPeer) peer).handleMouseMotionEvent(ev);
 340           }
 341       }
 342   }
 343
 344   /**
 345    * Handles key events on the component. This is usually forwarded to the
 346    * SwingComponent's processKeyEvent() method.
 347    *
 348    * @param e the key event
 349    */
 350   protected void handleKeyEvent(KeyEvent e)
 351   {
 352     Component owner = getFocusOwner();
 353     if(owner != null)
 354       owner.getPeer().handleEvent(e);
 355     else
 356       super.handleKeyEvent(e);
 357   }
 358
 359   private Component focusOwner = null;
 360
 361   private Component getFocusOwner()
 362   {
 363       if(focusOwner == null)
 364       {
 365         for(Iterator iter=heavyweightDescendents.iterator(); iter.hasNext();)
 366         {
 367            Component child = (Component) iter.next();
 368           if(child.isFocusable())
 369           {
 370               focusOwner = child;
 371             break;
 372           }
 373       }
 374       }
 375       return focusOwner;
 376   }
 377
 378 }