Esempio n. 1
0
        /// <summary>Flattens this element.
        /// Returns a promise which fires when the image has been rendered at least once.
        /// The promise contains a direct reference to the latest image.</summary>
        public Promise flatten()
        {
            // Obtain the raster data from the render data:
            RasterDisplayableProperty rdp = RenderData.RasterProperty;

            // Create the resultant promise:
            Promise p = new Promise();

            // Check if we already have an image:
            Texture img = rdp == null ? null : rdp.Output;

            if (img != null)
            {
                // Already got one! Resolve right away:
                p.resolve(img);
                return(p);
            }

            // If we don't have an RDP then request a flatten.
            // Output is null so we know it'll be getting drawn on the next update.
            if (rdp == null)
            {
                // (no full Loonim effects on this element):
                style.Computed.ChangeTagProperty("-spark-filter", "flatten");
            }

            Dom.EventListener listener = null;

            // Wait for the imagechange event:
            listener = new Dom.EventListener <Dom.Event>(delegate(Dom.Event e){
                // Image changed! Remove this listener:
                removeEventListener("imagechange", listener);

                // Update the promise:
                Texture current = flatImage;

                if (current == null)
                {
                    // Unable to flatten this (This should never happen).
                    p.reject(FLATTEN_FAILED);
                }
                else
                {
                    p.resolve(flatImage);
                }
            });

            // Add it:
            addEventListener("imagechange", listener);

            return(p);
        }
Esempio n. 2
0
        public override ApplyState Apply(ComputedStyle style, Value value)
        {
            RenderableData            rd  = style.RenderData;
            RasterDisplayableProperty rdp = rd.RasterProperty;

            if (value == null || value.IsType(typeof(Css.Keywords.None)))
            {
                // Remove RDP
                if (rdp != null)
                {
                    // Destroy it:
                    rdp.Destroy();

                    // Request a layout:
                    rdp.RequestLayout();

                    // Clear:
                    rd.RasterProperty = null;
                    rdp = null;
                }
            }
            else if (rdp == null)
            {
                // RDP required:
                rd.RasterProperty = rdp = new RasterDisplayableProperty(rd);

                // Update the filter now!
                BuildFilter(value, rd, delegate(RenderableData ctx, SurfaceTexture tex){
                    // Hopefully tex is not null!
                    // If so, we can write it into ctx.RasterProperty, which is hopefully
                    // still available:
                    RasterDisplayableProperty filterRdp = ctx.RasterProperty;

                    if (filterRdp != null)
                    {
                        // Alright - update it with the filter (which might be null).
                        // The filter goes between the FlatWorldUI and the Output.
                        filterRdp.SetFilter(tex);

                        // Request a layout:
                        filterRdp.RequestLayout();
                    }
                });
            }

            // Ok!
            return(ApplyState.Ok);
        }