Example #1
0
        internal static string DebugString(IFuture _future)
        {
            DebugHash debugHash = new DebugHash();

            _future.AccumulateRobustHash(debugHash);
            return(debugHash.ToString());
        }
Example #2
0
 public override void AccumulateRobustHash(IRobustHash hash)
 {
     hash.Accumulate("Cache(");
     cache.AccumulateRobustHash(hash);
     hash.Accumulate(",");
     future.AccumulateRobustHash(hash);
     hash.Accumulate(")");
 }
Example #3
0
 public override void AccumulateRobustHash(IRobustHash hash)
 {
     hash.Accumulate("TransparencyVerb(");
     transparencyOptions.AccumulateRobustHash(hash);
     antialiasedFuture.AccumulateRobustHash(hash);
     exactColorFuture.AccumulateRobustHash(hash);
     hash.Accumulate(")");
 }
        public void AccumulateRobustHash(IRobustHash hash)
        {
            hash.Accumulate("SourceImageDownsamplerVerb(");
            DummyTerm dummyTerm = new DummyTerm();
            IFuture   future    = prototype.Curry(new ParamDict(new object[]
            {
                TermName.ImageBounds, dummyTerm, TermName.OutputSize, dummyTerm, TermName.UseDocumentTransparency,
                dummyTerm, TermName.ExactColors, dummyTerm
            }));

            future.AccumulateRobustHash(hash);
            hash.Accumulate(")");
        }
Example #5
0
 public override void AccumulateRobustHash(IRobustHash hash)
 {
     hash.Accumulate("Apply(");
     this.verb.AccumulateRobustHash(hash);
     IFuture[] array = this.futureParams;
     for (int i = 0; i < array.Length; i++)
     {
         IFuture future = array[i];
         future.AccumulateRobustHash(hash);
         hash.Accumulate(",");
     }
     hash.Accumulate(")");
 }
Example #6
0
        public void AccumulateRobustHash(IRobustHash hash)
        {
            hash.Accumulate("UserBoundsRefVerb(");
            if (userRegion != null)
            {
                userRegion.AccumulateRobustHash(hash);
            }
            else
            {
                hash.Accumulate("null");
            }

            delayedStaticBoundsFuture.AccumulateRobustHash(hash);
            hash.Accumulate(")");
        }
Example #7
0
 public override void AccumulateRobustHash(IRobustHash hash)
 {
     hash.Accumulate("SynchronizingFuture(");
     asyncFuture.AccumulateRobustHash(hash);
     hash.Accumulate(")");
 }
 public override void AccumulateRobustHash(IRobustHash hash)
 {
     hash.Accumulate("ODSPF(");
     future.AccumulateRobustHash(hash);
     hash.Accumulate(")");
 }
		internal static string DebugString(IFuture _future)
		{
			DebugHash debugHash = new DebugHash();
			_future.AccumulateRobustHash(debugHash);
			return debugHash.ToString();
		}
Example #10
0
 public override void AccumulateRobustHash(IRobustHash hash)
 {
     hash.Accumulate("FetchDocumentFuture(");
     documentFuture.AccumulateRobustHash(hash);
     hash.Accumulate(")");
 }
        public Present Evaluate(Present[] paramList)
        {
            D.Assert(paramList.Length == 4);
            MapRectangleParameter parameter  = (MapRectangleParameter)paramList[0];
            SizeParameter         parameter2 = (SizeParameter)paramList[1];
            Present present  = paramList[2];
            Present present2 = paramList[3];
            double  num      = Math.Min(parameter.value.LonExtent, parameter.value.LatExtent);
            int     num2     = Math.Max(parameter2.value.Width, parameter2.value.Height);

            if ((num > 1.0) && (num2 <= 0x400))
            {
                IFuture    future = this.prototype.Curry(new ParamDict(new object[] { TermName.ImageBounds, new MapRectangleParameter(this.unitRectangle), TermName.OutputSize, new SizeParameter(this.memoizedSize), TermName.UseDocumentTransparency, present, TermName.ExactColors, present2 }));
                StrongHash hash   = new StrongHash();
                future.AccumulateRobustHash(hash);
                D.Sayf(0, "Future {0} hashes to {1}", new object[] { RobustHashTools.DebugString(future), hash.ToString() });
                Present present3 = future.Realize("sourceImageDownsampler-memo");
                if (present3 is ImageRef)
                {
                    try
                    {
                        ImageRef          ref2  = (ImageRef)present3;
                        GDIBigLockedImage image = new GDIBigLockedImage(parameter2.value, "sourceImageDownsampler-downsample");
                        lock (ref2.image)
                        {
                            lock (image)
                            {
                                Graphics     graphics = image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheGraphics();
                                MapRectangle region   = parameter.value.Intersect(this.unitRectangle);
                                if (!region.IsEmpty())
                                {
                                    RectangleF srcRect  = this.SelectSubRectangle(this.unitRectangle, region, this.memoizedSize);
                                    RectangleF destRect = this.SelectSubRectangle(parameter.value, region, parameter2.value);
                                    Image      image2   = ref2.image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
                                    graphics.InterpolationMode = InterpolationMode.HighQualityBilinear;
                                    graphics.DrawImage(image2, destRect, srcRect, GraphicsUnit.Pixel);
                                }
                                graphics.Dispose();
                                return(new ImageRef(new ImageRefCounted(image)));
                            }
                        }
                    }
                    catch (ArgumentException)
                    {
                        return(new PresentFailureCode("Image processing overflow"));
                    }
                    catch (OverflowException)
                    {
                        return(new PresentFailureCode("Image processing overflow"));
                    }
                    catch (Exception exception)
                    {
                        return(new PresentFailureCode(exception));
                    }
                    finally
                    {
                        present3.Dispose();
                    }
                }
                return(present3);
            }
            return(this.prototype.Curry(new ParamDict(new object[] { TermName.ImageBounds, parameter, TermName.OutputSize, parameter2, TermName.UseDocumentTransparency, present, TermName.ExactColors, present2 })).Realize("sourceImageDownsampler-passthru"));
        }
Example #12
0
 public override void AccumulateRobustHash(IRobustHash hash)
 {
     hash.Accumulate("AsynchronizerFuture(");
     innerFuture.AccumulateRobustHash(hash);
     hash.Accumulate(")");
 }