libjava/classpath/gnu/java/awt/peer/gtk/GdkGraphics.java

   1 /* GdkGraphics.java
   2    Copyright (C) 1998, 1999, 2002, 2005  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.gtk;
  40
  41 import gnu.classpath.Configuration;
  42
  43 import java.awt.Color;
  44 import java.awt.Dimension;
  45 import java.awt.Font;
  46 import java.awt.FontMetrics;
  47 import java.awt.Graphics;
  48 import java.awt.Image;
  49 import java.awt.Rectangle;
  50 import java.awt.Shape;
  51 import java.awt.Toolkit;
  52 import java.awt.image.ImageObserver;
  53 import java.text.AttributedCharacterIterator;
  54
  55 public class GdkGraphics extends Graphics
  56 {
  57   static
  58   {
  59     System.loadLibrary("gtkpeer");
  60
  61     initStaticState ();
  62   }
  63
  64   static native void initStaticState();
  65   private final int native_state = GtkGenericPeer.getUniqueInteger ();
  66
  67   Color color, xorColor;
  68   GtkComponentPeer component;
  69   Font font = new Font ("Dialog", Font.PLAIN, 12);
  70   Rectangle clip;
  71   GtkImage image;
  72
  73   int xOffset = 0;
  74   int yOffset = 0;
  75
  76   static final int GDK_COPY = 0, GDK_XOR = 2;
  77
  78   native void initState (GtkComponentPeer component);
  79   native void initStateUnlocked (GtkComponentPeer component);
  80   native void initState (int width, int height);
  81   native void initFromImage (GtkImage image);
  82   native void nativeCopyState (GdkGraphics g);
  83
  84   /**
  85    * A cached instance that is used by {@link #create} in order to avoid
  86    * massive allocation of graphics contexts.
  87    */
  88   GdkGraphics cached = null;
  89
  90   /**
  91    * A link to the parent context. This is used in {@link #dispose} to put
  92    * this graphics context into the cache.
  93    */
  94   GdkGraphics parent = null;
  95
  96   GdkGraphics (GdkGraphics g)
  97   {
  98     parent = g;
  99     copyState (g);
 100   }
 101
 102   GdkGraphics (int width, int height)
 103   {
 104     initState (width, height);
 105     color = Color.black;
 106     clip = new Rectangle (0, 0, width, height);
 107     font = new Font ("Dialog", Font.PLAIN, 12);
 108   }
 109
 110   GdkGraphics (GtkImage image)
 111   {
 112     this.image = image;
 113     initFromImage (image);
 114     color = Color.black;
 115     clip = new Rectangle (0, 0,
 116                           image.getWidth(null), image.getHeight(null));
 117     font = new Font ("Dialog", Font.PLAIN, 12);
 118   }
 119
 120   GdkGraphics (GtkComponentPeer component)
 121   {
 122     this.component = component;
 123     color = Color.black;
 124
 125     if (component.isRealized ())
 126       initComponentGraphics ();
 127     else
 128       connectSignals (component);
 129   }
 130
 131   void initComponentGraphics ()
 132   {
 133     initState (component);
 134     color = component.awtComponent.getForeground ();
 135     if (color == null)
 136       color = Color.BLACK;
 137     Dimension d = component.awtComponent.getSize ();
 138     clip = new Rectangle (0, 0, d.width, d.height);
 139   }
 140
 141   // called back by native side: realize_cb
 142   void initComponentGraphicsUnlocked ()
 143   {
 144     initStateUnlocked (component);
 145     color = component.awtComponent.getForeground ();
 146     if (color == null)
 147       color = Color.BLACK;
 148     Dimension d = component.awtComponent.getSize ();
 149     clip = new Rectangle (0, 0, d.width, d.height);
 150   }
 151
 152   native void connectSignals (GtkComponentPeer component);
 153
 154   public native void clearRect(int x, int y, int width, int height);
 155
 156   public void clipRect (int x, int y, int width, int height)
 157   {
 158     if (component != null && ! component.isRealized ())
 159       return;
 160
 161     clip = clip.intersection (new Rectangle (x, y, width, height));
 162     setClipRectangle (clip.x, clip.y, clip.width, clip.height);
 163   }
 164
 165   public native void copyArea(int x, int y, int width, int height,
 166                               int dx, int dy);
 167
 168   /**
 169    * Creates a copy of this GdkGraphics instance. This implementation can
 170    * reuse a cached instance to avoid massive instantiation of Graphics objects
 171    * during painting.
 172    *
 173    * @return a copy of this graphics context
 174    */
 175   public Graphics create()
 176   {
 177     GdkGraphics copy = cached;
 178     if (copy == null)
 179       copy = new GdkGraphics(this);
 180     else
 181       {
 182         copy.copyState(this);
 183         cached = null;
 184       }
 185     return copy;
 186   }
 187
 188   public native void nativeDispose();
 189
 190   /**
 191    * Disposes this graphics object. This puts this graphics context into the
 192    * cache of its parent graphics if there is one.
 193    */
 194   public void dispose()
 195   {
 196     if (parent != null)
 197       {
 198         parent.cached = this;
 199         parent = null;
 200       }
 201     else
 202       nativeDispose();
 203   }
 204
 205   /**
 206    * This is called when this object gets finalized by the garbage collector.
 207    * In addition to {@link Graphics#finalize()} this calls nativeDispose() to
 208    * make sure the native resources are freed before the graphics context is
 209    * thrown away.
 210    */
 211   public void finalize()
 212   {
 213     super.finalize();
 214     nativeDispose();
 215   }
 216
 217   public boolean drawImage (Image img, int x, int y,
 218                             Color bgcolor, ImageObserver observer)
 219   {
 220     if (img != null)
 221       return drawImage(img, x, y, img.getWidth(null), img.getHeight(null),
 222                        bgcolor, observer);
 223     return false;
 224   }
 225
 226   public boolean drawImage (Image img, int x, int y, ImageObserver observer)
 227   {
 228     return drawImage (img, x, y, null, observer);
 229   }
 230
 231   public boolean drawImage(Image img, int x, int y, int width, int height,
 232                            Color bgcolor, ImageObserver observer)
 233   {
 234     if (img != null)
 235       {
 236         if (img instanceof GtkImage)
 237           return ((GtkImage) img).drawImage(this, x, y, width, height, bgcolor,
 238                                             observer);
 239         return (new GtkImage(img.getSource())).drawImage(this, x, y, width,
 240                                                          height, bgcolor,
 241                                                          observer);
 242       }
 243     return false;
 244   }
 245
 246   public boolean drawImage (Image img, int x, int y, int width, int height,
 247                             ImageObserver observer)
 248   {
 249     return drawImage (img, x, y, width, height,  null, observer);
 250   }
 251
 252   public boolean drawImage (Image img, int dx1, int dy1, int dx2, int dy2,
 253                             int sx1, int sy1, int sx2, int sy2,
 254                             Color bgcolor, ImageObserver observer)
 255   {
 256     if (img != null)
 257       {
 258         if (img instanceof GtkImage)
 259           return ((GtkImage) img).drawImage(this, dx1, dy1, dx2, dy2, sx1, sy1,
 260                                             sx2, sy2, bgcolor, observer);
 261         return (new GtkImage(img.getSource())).drawImage(this, dx1, dy1, dx2,
 262                                                          dy2, sx1, sy1, sx2,
 263                                                          sy2, bgcolor, observer);
 264       }
 265     return false;
 266   }
 267
 268   public boolean drawImage (Image img, int dx1, int dy1, int dx2, int dy2,
 269                             int sx1, int sy1, int sx2, int sy2,
 270                             ImageObserver observer)
 271   {
 272     return drawImage (img, dx1, dy1, dx2, dy2,
 273                       sx1, sy1, sx2, sy2,
 274                       null, observer);
 275   }
 276
 277   public native void drawLine(int x1, int y1, int x2, int y2);
 278
 279   public native void drawArc(int x, int y, int width, int height,
 280                              int startAngle, int arcAngle);
 281   public native void fillArc(int x, int y, int width, int height,
 282                              int startAngle, int arcAngle);
 283   public native void drawOval(int x, int y, int width, int height);
 284   public native void fillOval(int x, int y, int width, int height);
 285
 286   public native void drawPolygon(int[] xPoints, int[] yPoints, int nPoints);
 287   public native void fillPolygon(int[] xPoints, int[] yPoints, int nPoints);
 288
 289   public native void drawPolyline(int[] xPoints, int[] yPoints, int nPoints);
 290
 291   public native void drawRect(int x, int y, int width, int height);
 292   public native void fillRect(int x, int y, int width, int height);
 293
 294   GdkFontPeer getFontPeer()
 295   {
 296     return (GdkFontPeer) getFont().getPeer();
 297   }
 298
 299   native void drawString (GdkFontPeer f, String str, int x, int y);
 300   public void drawString (String str, int x, int y)
 301   {
 302     drawString(getFontPeer(), str, x, y);
 303   }
 304
 305   public void drawString (AttributedCharacterIterator ci, int x, int y)
 306   {
 307     throw new Error ("not implemented");
 308   }
 309
 310   public void drawRoundRect(int x, int y, int width, int height,
 311                             int arcWidth, int arcHeight)
 312   {
 313     if (arcWidth > width)
 314       arcWidth = width;
 315     if (arcHeight > height)
 316       arcHeight = height;
 317
 318     int xx = x + width - arcWidth;
 319     int yy = y + height - arcHeight;
 320
 321     drawArc (x, y, arcWidth, arcHeight, 90, 90);
 322     drawArc (xx, y, arcWidth, arcHeight, 0, 90);
 323     drawArc (xx, yy, arcWidth, arcHeight, 270, 90);
 324     drawArc (x, yy, arcWidth, arcHeight, 180, 90);
 325
 326     int y1 = y + arcHeight / 2;
 327     int y2 = y + height - arcHeight / 2;
 328     drawLine (x, y1, x, y2);
 329     drawLine (x + width, y1, x + width, y2);
 330
 331     int x1 = x + arcWidth / 2;
 332     int x2 = x + width - arcWidth / 2;
 333     drawLine (x1, y, x2, y);
 334     drawLine (x1, y + height, x2, y + height);
 335   }
 336
 337   public void fillRoundRect (int x, int y, int width, int height,
 338                              int arcWidth, int arcHeight)
 339   {
 340     if (arcWidth > width)
 341       arcWidth = width;
 342     if (arcHeight > height)
 343       arcHeight = height;
 344
 345     int xx = x + width - arcWidth;
 346     int yy = y + height - arcHeight;
 347
 348     fillArc (x, y, arcWidth, arcHeight, 90, 90);
 349     fillArc (xx, y, arcWidth, arcHeight, 0, 90);
 350     fillArc (xx, yy, arcWidth, arcHeight, 270, 90);
 351     fillArc (x, yy, arcWidth, arcHeight, 180, 90);
 352
 353     fillRect (x, y + arcHeight / 2, width, height - arcHeight + 1);
 354     fillRect (x + arcWidth / 2, y, width - arcWidth + 1, height);
 355   }
 356
 357   public Shape getClip ()
 358   {
 359     return getClipBounds ();
 360   }
 361
 362   public Rectangle getClipBounds ()
 363   {
 364     if (clip == null)
 365       return null;
 366     else
 367       return clip.getBounds();
 368   }
 369
 370   public Color getColor ()
 371   {
 372     return color;
 373   }
 374
 375   public Font getFont ()
 376   {
 377     return font;
 378   }
 379
 380   public FontMetrics getFontMetrics (Font font)
 381   {
 382     // Get the font metrics through GtkToolkit to take advantage of
 383     // the metrics cache.
 384     return Toolkit.getDefaultToolkit().getFontMetrics (font);
 385   }
 386
 387   native void setClipRectangle (int x, int y, int width, int height);
 388
 389   public void setClip (int x, int y, int width, int height)
 390   {
 391     if ((component != null && ! component.isRealized ())
 392         || clip == null)
 393       return;
 394
 395     clip.x = x;
 396     clip.y = y;
 397     clip.width = width;
 398     clip.height = height;
 399
 400     setClipRectangle (x, y, width, height);
 401   }
 402
 403   public void setClip (Rectangle clip)
 404   {
 405     setClip (clip.x, clip.y, clip.width, clip.height);
 406   }
 407
 408   public void setClip (Shape clip)
 409   {
 410     if (clip == null)
 411       {
 412         // Reset clipping.
 413         Dimension d = component.awtComponent.getSize();
 414         setClip(new Rectangle (0, 0, d.width, d.height));
 415       }
 416     else
 417       setClip(clip.getBounds());
 418   }
 419
 420   private native void setFGColor(int red, int green, int blue);
 421
 422   public void setColor (Color c)
 423   {
 424     if (c == null)
 425       color = Color.BLACK;
 426     else
 427       color = c;
 428
 429     if (xorColor == null) /* paint mode */
 430       setFGColor (color.getRed (), color.getGreen (), color.getBlue ());
 431     else                  /* xor mode */
 432       setFGColor (color.getRed   () ^ xorColor.getRed (),
 433                   color.getGreen () ^ xorColor.getGreen (),
 434                   color.getBlue  () ^ xorColor.getBlue ());
 435   }
 436
 437   public void setFont (Font font)
 438   {
 439     if (font != null)
 440       this.font = font;
 441   }
 442
 443   native void setFunction (int gdk_func);
 444
 445   public void setPaintMode ()
 446   {
 447     xorColor = null;
 448
 449     setFunction (GDK_COPY);
 450     setFGColor (color.getRed (), color.getGreen (), color.getBlue ());
 451   }
 452
 453   public void setXORMode (Color c)
 454   {
 455     xorColor = c;
 456
 457     setFunction (GDK_XOR);
 458     setFGColor (color.getRed   () ^ xorColor.getRed (),
 459                 color.getGreen () ^ xorColor.getGreen (),
 460                 color.getBlue  () ^ xorColor.getBlue ());
 461   }
 462
 463   public native void translateNative(int x, int y);
 464
 465   public void translate (int x, int y)
 466   {
 467     if (component != null && ! component.isRealized ())
 468       return;
 469
 470     clip.x -= x;
 471     clip.y -= y;
 472
 473     translateNative (x, y);
 474   }
 475
 476   /**
 477    * Copies over the state of another GdkGraphics to this instance. This is
 478    * used by the {@link #GdkGraphics(GdkGraphics)} constructor and the
 479    * {@link #create()} method.
 480    *
 481    * @param g the GdkGraphics object to copy the state from
 482    */
 483   private void copyState(GdkGraphics g)
 484   {
 485     color = g.color;
 486     xorColor = g.xorColor;
 487     font = g.font;
 488     if (font == null)
 489       font = new Font ("Dialog", Font.PLAIN, 12);
 490     clip = new Rectangle (g.clip);
 491     component = g.component;
 492     nativeCopyState(g);
 493   }
 494 }