/// <summary> /// Flushes all reconstructable resources being used by this Image object. /// This includes any pixel data that is being cached for rendering to /// the screen as well as any system resources that are being used /// to store data or pixels for the image if they can be recreated. /// The image is reset to a state similar to when it was first created /// so that if it is again rendered, the image data will have to be /// recreated or fetched again from its source. /// <para> /// Examples of how this method affects specific types of Image object: /// <ul> /// <li> /// BufferedImage objects leave the primary Raster which stores their /// pixels untouched, but flush any information cached about those /// pixels such as copies uploaded to the display hardware for /// accelerated blits. /// <li> /// Image objects created by the Component methods which take a /// width and height leave their primary buffer of pixels untouched, /// but have all cached information released much like is done for /// BufferedImage objects. /// <li> /// VolatileImage objects release all of their pixel resources /// including their primary copy which is typically stored on /// the display hardware where resources are scarce. /// These objects can later be restored using their /// <seealso cref="java.awt.image.VolatileImage#validate validate"/> /// method. /// <li> /// Image objects created by the Toolkit and Component classes which are /// loaded from files, URLs or produced by an <seealso cref="ImageProducer"/> /// are unloaded and all local resources are released. /// These objects can later be reloaded from their original source /// as needed when they are rendered, just as when they were first /// created. /// </ul> /// </para> /// </summary> public virtual void Flush() { if (SurfaceManager != null) { SurfaceManager.flush(); } }
/// <summary> /// Returns an ImageCapabilities object which can be /// inquired as to the capabilities of this /// Image on the specified GraphicsConfiguration. /// This allows programmers to find /// out more runtime information on the specific Image /// object that they have created. For example, the user /// might create a BufferedImage but the system may have /// no video memory left for creating an image of that /// size on the given GraphicsConfiguration, so although the object /// may be acceleratable in general, it /// does not have that capability on this GraphicsConfiguration. </summary> /// <param name="gc"> a <code>GraphicsConfiguration</code> object. A value of null /// for this parameter will result in getting the image capabilities /// for the default <code>GraphicsConfiguration</code>. </param> /// <returns> an <code>ImageCapabilities</code> object that contains /// the capabilities of this <code>Image</code> on the specified /// GraphicsConfiguration. </returns> /// <seealso cref= java.awt.image.VolatileImage#getCapabilities() /// VolatileImage.getCapabilities() /// @since 1.5 </seealso> public virtual ImageCapabilities GetCapabilities(GraphicsConfiguration gc) { if (SurfaceManager != null) { return(SurfaceManager.getCapabilities(gc)); } // Note: this is just a default object that gets returned in the // absence of any more specific information from a surfaceManager. // Subclasses of Image should either override this method or // make sure that they always have a non-null SurfaceManager // to return an ImageCapabilities object that is appropriate // for their given subclass type. return(DefaultImageCaps); }
public virtual void SetSurfaceManager(Image img, SurfaceManager mgr) { img.SurfaceManager = mgr; }