1 /*
   2  * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.java2d.xr;
  27 
  28 import java.awt.*;
  29 import java.awt.geom.*;
  30 import java.awt.image.*;
  31 import sun.awt.*;
  32 import sun.java2d.InvalidPipeException;
  33 import sun.java2d.SunGraphics2D;
  34 import sun.java2d.SurfaceData;
  35 import sun.java2d.SurfaceDataProxy;
  36 import sun.java2d.jules.*;
  37 import sun.java2d.loops.*;
  38 import sun.java2d.pipe.*;
  39 import sun.java2d.x11.*;
  40 import sun.font.FontManagerNativeLibrary;
  41 
  42 public abstract class XRSurfaceData extends XSurfaceData {
  43     X11ComponentPeer peer;
  44     XRGraphicsConfig graphicsConfig;
  45     XRBackend renderQueue;
  46 
  47     private RenderLoops solidloops;
  48 
  49     protected int depth;
  50 
  51     private static native void initIDs();
  52 
  53     protected native void XRInitSurface(int depth, int width, int height,
  54                                         long drawable, int pictFormat);
  55 
  56     native void initXRPicture(long xsdo, int pictForm);
  57 
  58     native void freeXSDOPicture(long xsdo);
  59 
  60     public static final String DESC_BYTE_A8_X11 = "Byte A8 Pixmap";
  61     public static final String DESC_INT_RGB_X11 = "Integer RGB Pixmap";
  62     public static final String DESC_INT_ARGB_X11 = "Integer ARGB-Pre Pixmap";
  63 
  64     public static final SurfaceType
  65         ByteA8X11 = SurfaceType.ByteGray.deriveSubType(DESC_BYTE_A8_X11);
  66     public static final SurfaceType
  67         IntRgbX11 = SurfaceType.IntRgb.deriveSubType(DESC_INT_RGB_X11);
  68     public static final SurfaceType
  69         IntArgbPreX11 = SurfaceType.IntArgbPre.deriveSubType(DESC_INT_ARGB_X11);
  70 
  71     public Raster getRaster(int x, int y, int w, int h) {
  72         throw new InternalError("not implemented yet");
  73     }
  74 
  75     protected XRRenderer xrpipe;
  76     protected PixelToShapeConverter xrtxpipe;
  77     protected TextPipe xrtextpipe;
  78     protected XRDrawImage xrDrawImage;
  79 
  80     protected ShapeDrawPipe aaShapePipe;
  81     protected PixelToShapeConverter aaPixelToShapeConv;
  82 
  83     public static void initXRSurfaceData() {
  84         if (!isX11SurfaceDataInitialized()) {
  85             FontManagerNativeLibrary.load();
  86             initIDs();
  87             XRPMBlitLoops.register();
  88             XRMaskFill.register();
  89             XRMaskBlit.register();
  90 
  91             setX11SurfaceDataInitialized();
  92         }
  93     }
  94 
  95     /**
  96      * Synchronized accessor method for isDrawableValid.
  97      */
  98     protected boolean isXRDrawableValid() {
  99         try {
 100             SunToolkit.awtLock();
 101             return isDrawableValid();
 102         } finally {
 103             SunToolkit.awtUnlock();
 104         }
 105     }
 106 
 107     @Override
 108     public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {
 109         return XRSurfaceDataProxy.createProxy(srcData, graphicsConfig);
 110     }
 111 
 112     public void validatePipe(SunGraphics2D sg2d) {
 113         TextPipe textpipe;
 114         boolean validated = false;
 115 
 116         /*
 117          * The textpipe for now can't handle TexturePaint when extra-alpha is
 118          * specified nore XOR mode
 119          */
 120         if (sg2d.compositeState < SunGraphics2D.COMP_XOR &&
 121             (sg2d.paintState < SunGraphics2D.PAINT_TEXTURE ||
 122              sg2d.composite == null ||
 123              !(sg2d.composite instanceof AlphaComposite) ||
 124              ((AlphaComposite) sg2d.composite).getAlpha() == 1.0f))
 125         {
 126             textpipe = xrtextpipe;
 127         } else {
 128             super.validatePipe(sg2d);
 129             textpipe = sg2d.textpipe;
 130             validated = true;
 131         }
 132 
 133         PixelToShapeConverter txPipe = null;
 134         XRRenderer nonTxPipe = null;
 135 
 136         /*
 137          * TODO: Can we rely on the GC for ARGB32 surfaces?
 138          */
 139         if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) {
 140             if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) {
 141                 if (sg2d.compositeState <= SunGraphics2D.COMP_XOR) {
 142                     txPipe = xrtxpipe;
 143                     nonTxPipe = xrpipe;
 144                 }
 145             } else if (sg2d.compositeState <= SunGraphics2D.COMP_ALPHA) {
 146                 if (XRPaints.isValid(sg2d)) {
 147                     txPipe = xrtxpipe;
 148                     nonTxPipe = xrpipe;
 149                 }
 150                 // custom paints handled by super.validatePipe() below
 151             }
 152         }
 153 
 154         if (sg2d.antialiasHint == SunHints.INTVAL_ANTIALIAS_ON &&
 155             JulesPathBuf.isCairoAvailable())
 156         {
 157             sg2d.shapepipe = aaShapePipe;
 158             sg2d.drawpipe = aaPixelToShapeConv;
 159             sg2d.fillpipe = aaPixelToShapeConv;
 160         } else {
 161             if (txPipe != null) {
 162                 if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
 163                     sg2d.drawpipe = txPipe;
 164                     sg2d.fillpipe = txPipe;
 165                 } else if (sg2d.strokeState != SunGraphics2D.STROKE_THIN) {
 166                     sg2d.drawpipe = txPipe;
 167                     sg2d.fillpipe = nonTxPipe;
 168                 } else {
 169                     sg2d.drawpipe = nonTxPipe;
 170                     sg2d.fillpipe = nonTxPipe;
 171                 }
 172                 sg2d.shapepipe = nonTxPipe;
 173             } else {
 174                 if (!validated) {
 175                     super.validatePipe(sg2d);
 176                 }
 177             }
 178         }
 179 
 180         // install the text pipe based on our earlier decision
 181         sg2d.textpipe = textpipe;
 182 
 183         // always override the image pipe with the specialized XRender pipe
 184         sg2d.imagepipe = xrDrawImage;
 185     }
 186 
 187     protected MaskFill getMaskFill(SunGraphics2D sg2d) {
 188         if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR &&
 189             !XRPaints.isValid(sg2d))
 190         {
 191             return null;
 192         }
 193         return super.getMaskFill(sg2d);
 194     }
 195 
 196     public RenderLoops getRenderLoops(SunGraphics2D sg2d) {
 197         if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR &&
 198             sg2d.compositeState <= SunGraphics2D.COMP_ALPHA)
 199         {
 200             return solidloops;
 201         }
 202 
 203         return super.getRenderLoops(sg2d);
 204     }
 205 
 206     public GraphicsConfiguration getDeviceConfiguration() {
 207         return graphicsConfig;
 208     }
 209 
 210     /**
 211      * Method for instantiating a Window SurfaceData
 212      */
 213     public static XRWindowSurfaceData createData(X11ComponentPeer peer) {
 214         XRGraphicsConfig gc = getGC(peer);
 215         return new XRWindowSurfaceData(peer, gc, gc.getSurfaceType());
 216     }
 217 
 218     /**
 219      * Method for instantiating a Pixmap SurfaceData (offscreen).
 220      * If the surface * is opaque a 24-bit/RGB surface is chosen,
 221      * otherwise a 32-bit ARGB surface.
 222      */
 223     public static XRPixmapSurfaceData createData(XRGraphicsConfig gc,
 224                                                  int width, int height,
 225                                                  ColorModel cm, Image image,
 226                                                  long drawable,
 227                                                  int transparency) {
 228         int depth = transparency > Transparency.OPAQUE ? 32 : 24;
 229         if (depth == 24) {
 230             cm = new DirectColorModel(depth,
 231                                       0x00FF0000, 0x0000FF00, 0x000000FF);
 232         } else {
 233             cm = new DirectColorModel(depth, 0x00FF0000, 0x0000FF00,
 234                                       0x000000FF, 0xFF000000);
 235         }
 236 
 237         return new XRPixmapSurfaceData
 238             (gc, width, height, image, getSurfaceType(gc, transparency),
 239              cm, drawable, transparency,
 240              XRUtils.getPictureFormatForTransparency(transparency), depth);
 241     }
 242 
 243     protected XRSurfaceData(X11ComponentPeer peer, XRGraphicsConfig gc,
 244         SurfaceType sType, ColorModel cm, int depth, int transparency)
 245     {
 246         super(sType, cm);
 247         this.peer = peer;
 248         this.graphicsConfig = gc;
 249         this.solidloops = graphicsConfig.getSolidLoops(sType);
 250         this.depth = depth;
 251         initOps(peer, graphicsConfig, depth);
 252 
 253         setBlitProxyKey(gc.getProxyKey());
 254     }
 255 
 256     protected XRSurfaceData(XRBackend renderQueue) {
 257         super(XRSurfaceData.IntRgbX11,
 258               new DirectColorModel(24, 0x00FF0000, 0x0000FF00, 0x000000FF));
 259         this.renderQueue = renderQueue;
 260     }
 261 
 262     /**
 263      * Inits the XRender-data-structures which belong to the XRSurfaceData.
 264      *
 265      * @param pictureFormat
 266      */
 267     public void initXRender(int pictureFormat) {
 268         try {
 269             SunToolkit.awtLock();
 270             initXRPicture(getNativeOps(), pictureFormat);
 271             renderQueue = XRCompositeManager.getInstance(this).getBackend();
 272             maskBuffer = XRCompositeManager.getInstance(this);
 273         } catch (Throwable ex) {
 274             ex.printStackTrace();
 275         } finally {
 276             SunToolkit.awtUnlock();
 277         }
 278     }
 279 
 280     public static XRGraphicsConfig getGC(X11ComponentPeer peer) {
 281         if (peer != null) {
 282             return (XRGraphicsConfig) peer.getGraphicsConfiguration();
 283         } else {
 284             GraphicsEnvironment env =
 285                 GraphicsEnvironment.getLocalGraphicsEnvironment();
 286             GraphicsDevice gd = env.getDefaultScreenDevice();
 287             return (XRGraphicsConfig) gd.getDefaultConfiguration();
 288         }
 289     }
 290 
 291     /**
 292      * Returns a boolean indicating whether or not a copyArea from the given
 293      * rectangle source coordinates might be incomplete and result in X11
 294      * GraphicsExposure events being generated from XCopyArea. This method
 295      * allows the SurfaceData copyArea method to determine if it needs to set
 296      * the GraphicsExposures attribute of the X11 GC to True or False to receive
 297      * or avoid the events.
 298      *
 299      * @return true if there is any chance that an XCopyArea from the given
 300      *         source coordinates could produce any X11 Exposure events.
 301      */
 302     public abstract boolean canSourceSendExposures(int x, int y, int w, int h);
 303 
 304     /**
 305      * CopyArea is implemented using the "old" X11 GC, therefor clip and
 306      * needExposures have to be validated against that GC. Pictures and GCs
 307      * don't share state.
 308      */
 309     public void validateCopyAreaGC(Region gcClip, boolean needExposures) {
 310         if (validatedGCClip != gcClip) {
 311             if (gcClip != null)
 312                 renderQueue.setGCClipRectangles(xgc, gcClip);
 313             validatedGCClip = gcClip;
 314         }
 315 
 316         if (validatedExposures != needExposures) {
 317             validatedExposures = needExposures;
 318             renderQueue.setGCExposures(xgc, needExposures);
 319         }
 320 
 321         if (validatedXorComp != null) {
 322             renderQueue.setGCMode(xgc, true);
 323             renderQueue.setGCForeground(xgc, validatedGCForegroundPixel);
 324             validatedXorComp = null;
 325         }
 326     }
 327 
 328     public boolean copyArea(SunGraphics2D sg2d, int x, int y, int w, int h,
 329                             int dx, int dy) {
 330         if (xrpipe == null) {
 331             if (!isXRDrawableValid()) {
 332                 return true;
 333             }
 334             makePipes();
 335         }
 336         CompositeType comptype = sg2d.imageComp;
 337         if (sg2d.transformState < SunGraphics2D.TRANSFORM_TRANSLATESCALE &&
 338             (CompositeType.SrcOverNoEa.equals(comptype) ||
 339              CompositeType.SrcNoEa.equals(comptype)))
 340         {
 341             x += sg2d.transX;
 342             y += sg2d.transY;
 343             try {
 344                 SunToolkit.awtLock();
 345                 boolean needExposures = canSourceSendExposures(x, y, w, h);
 346                 validateCopyAreaGC(sg2d.getCompClip(), needExposures);
 347                 renderQueue.copyArea(xid, xid, xgc, x, y, w, h, x + dx, y + dy);
 348             } finally {
 349                 SunToolkit.awtUnlock();
 350             }
 351             return true;
 352         }
 353         return false;
 354     }
 355 
 356     /**
 357      * Returns the XRender SurfaceType which is able to fullfill the specified
 358      * transparency requirement.
 359      */
 360     public static SurfaceType getSurfaceType(XRGraphicsConfig gc,
 361                                              int transparency) {
 362         SurfaceType sType = null;
 363 
 364         switch (transparency) {
 365         case Transparency.OPAQUE:
 366             sType = XRSurfaceData.IntRgbX11;
 367             break;
 368 
 369         case Transparency.BITMASK:
 370         case Transparency.TRANSLUCENT:
 371             sType = XRSurfaceData.IntArgbPreX11;
 372             break;
 373         }
 374 
 375         return sType;
 376     }
 377 
 378     public void invalidate() {
 379         if (isValid()) {
 380             setInvalid();
 381             super.invalidate();
 382         }
 383     }
 384 
 385     private long xgc; // GC is still used for copyArea
 386     private int validatedGCForegroundPixel = 0;
 387     private XORComposite validatedXorComp;
 388     private int xid;
 389     public int picture;
 390     public XRCompositeManager maskBuffer;
 391 
 392     private Region validatedClip;
 393     private Region validatedGCClip;
 394     private boolean validatedExposures = true;
 395 
 396     boolean transformInUse = false;
 397     AffineTransform validatedSourceTransform = new AffineTransform();
 398     int validatedRepeat = XRUtils.RepeatNone;
 399     int validatedFilter = XRUtils.FAST;
 400 
 401     /**
 402      * Validates an XRSurfaceData when used as source. Note that the clip is
 403      * applied when used as source as well as destination.
 404      */
 405     void validateAsSource(AffineTransform sxForm, int repeat, int filter) {
 406 
 407         if (validatedClip != null) {
 408             validatedClip = null;
 409             renderQueue.setClipRectangles(picture, null);
 410         }
 411 
 412         if (validatedRepeat != repeat && repeat != -1) {
 413             validatedRepeat = repeat;
 414             renderQueue.setPictureRepeat(picture, repeat);
 415         }
 416 
 417         if (sxForm == null) {
 418             if (transformInUse) {
 419                 validatedSourceTransform.setToIdentity();
 420                 renderQueue.setPictureTransform(picture,
 421                                                 validatedSourceTransform);
 422                 transformInUse = false;
 423             }
 424         } else if (!transformInUse ||
 425                    (transformInUse && !sxForm.equals(validatedSourceTransform))) {
 426             validatedSourceTransform.setTransform(sxForm.getScaleX(),
 427                                                   sxForm.getShearY(),
 428                                                   sxForm.getShearX(),
 429                                                   sxForm.getScaleY(),
 430                                                   sxForm.getTranslateX(),
 431                                                   sxForm.getTranslateY());
 432             renderQueue.setPictureTransform(picture, validatedSourceTransform);
 433             transformInUse = true;
 434         }
 435 
 436         if (filter != validatedFilter && filter != -1) {
 437             renderQueue.setFilter(picture, filter);
 438             validatedFilter = filter;
 439         }
 440     }
 441 
 442     /**
 443      * Validates the Surface when used as destination.
 444      */
 445     public void validateAsDestination(SunGraphics2D sg2d, Region clip) {
 446         if (!isValid()) {
 447             throw new InvalidPipeException("bounds changed");
 448         }
 449 
 450         boolean updateGCClip = false;
 451         if (clip != validatedClip) {
 452             renderQueue.setClipRectangles(picture, clip);
 453             validatedClip = clip;
 454             updateGCClip = true;
 455         }
 456 
 457         if (sg2d != null && sg2d.compositeState == SunGraphics2D.COMP_XOR) {
 458             if (validatedXorComp != sg2d.getComposite()) {
 459                 validatedXorComp = (XORComposite) sg2d.getComposite();
 460                 renderQueue.setGCMode(xgc, false);
 461             }
 462 
 463             // validate pixel
 464             int pixel = sg2d.pixel;
 465             if (validatedGCForegroundPixel != pixel) {
 466                 int xorpixelmod = validatedXorComp.getXorPixel();
 467                 renderQueue.setGCForeground(xgc, pixel ^ xorpixelmod);
 468                 validatedGCForegroundPixel = pixel;
 469             }
 470 
 471             if (updateGCClip) {
 472                 renderQueue.setGCClipRectangles(xgc, clip);
 473             }
 474         }
 475     }
 476 
 477     public synchronized void makePipes() { /*
 478                                             * TODO: Why is this synchronized,
 479                                             * but access not?
 480                                             */
 481         if (xrpipe == null) {
 482             try {
 483                 SunToolkit.awtLock();
 484                 xgc = XCreateGC(getNativeOps());
 485 
 486                 xrpipe = new XRRenderer(maskBuffer.getMaskBuffer());
 487                 xrtxpipe = new PixelToShapeConverter(xrpipe);
 488                 xrtextpipe = maskBuffer.getTextRenderer();
 489                 xrDrawImage = new XRDrawImage();
 490 
 491                 if (JulesPathBuf.isCairoAvailable()) {
 492                     aaShapePipe =
 493                        new JulesShapePipe(XRCompositeManager.getInstance(this));
 494                     aaPixelToShapeConv = new PixelToShapeConverter(aaShapePipe);
 495                 }
 496             } finally {
 497                 SunToolkit.awtUnlock();
 498             }
 499         }
 500     }
 501 
 502     public static class XRWindowSurfaceData extends XRSurfaceData {
 503         public XRWindowSurfaceData(X11ComponentPeer peer,
 504                                    XRGraphicsConfig gc, SurfaceType sType) {
 505             super(peer, gc, sType, peer.getColorModel(),
 506                   peer.getColorModel().getPixelSize(), Transparency.OPAQUE);
 507 
 508             if (isXRDrawableValid()) {
 509                 initXRender(XRUtils.
 510                     getPictureFormatForTransparency(Transparency.OPAQUE));
 511                 makePipes();
 512             }
 513         }
 514 
 515         public SurfaceData getReplacement() {
 516             return peer.getSurfaceData();
 517         }
 518 
 519         public Rectangle getBounds() {
 520             Rectangle r = peer.getBounds();
 521             r.x = r.y = 0;
 522             return r;
 523         }
 524 
 525         @Override
 526         public boolean canSourceSendExposures(int x, int y, int w, int h) {
 527             return true;
 528         }
 529 
 530         /**
 531          * Returns destination Component associated with this SurfaceData.
 532          */
 533         public Object getDestination() {
 534             return peer.getTarget();
 535         }
 536 
 537        public void invalidate() {
 538            try {
 539                SunToolkit.awtLock();
 540                freeXSDOPicture(getNativeOps());
 541            }finally {
 542                SunToolkit.awtUnlock();
 543            }
 544 
 545            super.invalidate();
 546        }
 547     }
 548 
 549     public static class XRInternalSurfaceData extends XRSurfaceData {
 550         public XRInternalSurfaceData(XRBackend renderQueue, int pictXid,
 551                                      AffineTransform transform) {
 552           super(renderQueue);
 553           this.picture = pictXid;
 554           this.validatedSourceTransform = transform;
 555 
 556           if (validatedSourceTransform != null) {
 557               transformInUse = true;
 558           }
 559         }
 560 
 561         public boolean canSourceSendExposures(int x, int y, int w, int h) {
 562             return false;
 563         }
 564 
 565         public Rectangle getBounds() {
 566             return null;
 567         }
 568 
 569         public Object getDestination() {
 570             return null;
 571         }
 572 
 573         public SurfaceData getReplacement() {
 574             return null;
 575         }
 576     }
 577 
 578     public static class XRPixmapSurfaceData extends XRSurfaceData {
 579         Image offscreenImage;
 580         int width;
 581         int height;
 582         int transparency;
 583 
 584         public XRPixmapSurfaceData(XRGraphicsConfig gc, int width, int height,
 585                                    Image image, SurfaceType sType,
 586                                    ColorModel cm, long drawable,
 587                                    int transparency, int pictFormat,
 588                                    int depth) {
 589             super(null, gc, sType, cm, depth, transparency);
 590             this.width = width;
 591             this.height = height;
 592             offscreenImage = image;
 593             this.transparency = transparency;
 594             initSurface(depth, width, height, drawable, pictFormat);
 595 
 596             initXRender(pictFormat);
 597             makePipes();
 598         }
 599 
 600         public void initSurface(int depth, int width, int height,
 601                                 long drawable, int pictFormat) {
 602             try {
 603                 SunToolkit.awtLock();
 604                 XRInitSurface(depth, width, height, drawable, pictFormat);
 605             } finally {
 606                 SunToolkit.awtUnlock();
 607             }
 608         }
 609 
 610         public SurfaceData getReplacement() {
 611             return restoreContents(offscreenImage);
 612         }
 613 
 614         /**
 615          * Need this since the surface data is created with the color model of
 616          * the target GC, which is always opaque. But in SunGraphics2D.blitSD we
 617          * choose loops based on the transparency on the source SD, so it could
 618          * choose wrong loop (blit instead of blitbg, for example).
 619          */
 620         public int getTransparency() {
 621             return transparency;
 622         }
 623 
 624         public Rectangle getBounds() {
 625             return new Rectangle(width, height);
 626         }
 627 
 628         @Override
 629         public boolean canSourceSendExposures(int x, int y, int w, int h) {
 630             return (x < 0 || y < 0 || (x + w) > width || (y + h) > height);
 631         }
 632 
 633         public void flush() {
 634             /*
 635              * We need to invalidate the surface before disposing the native
 636              * Drawable and Picture. This way if an application tries to render
 637              * to an already flushed XRSurfaceData, we will notice in the
 638              * validate() method above that it has been invalidated, and we will
 639              * avoid using those native resources that have already been
 640              * disposed.
 641              */
 642             invalidate();
 643             flushNativeSurface();
 644         }
 645 
 646         /**
 647          * Returns destination Image associated with this SurfaceData.
 648          */
 649         public Object getDestination() {
 650             return offscreenImage;
 651         }
 652     }
 653 
 654     public long getGC() {
 655         return xgc;
 656     }
 657 
 658     public static class LazyPipe extends ValidatePipe {
 659         public boolean validate(SunGraphics2D sg2d) {
 660             XRSurfaceData xsd = (XRSurfaceData) sg2d.surfaceData;
 661             if (!xsd.isXRDrawableValid()) {
 662                 return false;
 663             }
 664             xsd.makePipes();
 665             return super.validate(sg2d);
 666         }
 667     }
 668 
 669     public int getPicture() {
 670         return picture;
 671     }
 672 
 673     public int getXid() {
 674         return xid;
 675     }
 676 
 677     public XRGraphicsConfig getGraphicsConfig() {
 678         return graphicsConfig;
 679     }
 680 }