private Task <IImageProvider> CreateTestEffectAsync(LayerContext layerContext)
{
return(Task.Factory.StartNew <IImageProvider>(() => new FilterEffect()
{
Filters = new IFilter[] { new ReframingFilter(new Rect(new Point(0, 0), layerContext.BackgroundLayer.ImageSize), 0.0) }
}));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
var routeBuilder = new RouteBuilder(app);
routeBuilder.MapRoute("TryDBConnection",
async context =>
{
LayerContext db = new LayerContext();
db.Admins.Add(new Admin());
db.SaveChanges();
await context.Response.WriteAsync("ok");
}
);
app.UseRouter(routeBuilder.Build());
if (env.IsDevelopment())
{
app.UseBrowserLink();
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
private LayerContext CreateFakeLayerContext(Layer backgroundLayer, IImageProvider backgroundImage, Layer layer)
{
var invariants = new LayerContext.Invariants(backgroundLayer, new MaybeTask <IImageProvider>(backgroundImage), new Size(0, 0));
var layerContext = new LayerContext(invariants, backgroundLayer, layer, 1);
layerContext.PreviousImage = layerContext.BackgroundImage;
return(layerContext);
}
private IImageProvider CreateTestEffect(LayerContext layerContext)
{
return(new FilterEffect()
{
Filters = new IFilter[]
{
new ReframingFilter(new Rect(new Point(0, 0), layerContext.BackgroundLayer.ImageSize), 0.0)
}
});
}
private LayerContext CreateFakeLayerContext(Layer layer)
{
var backgroundImage = new ColorImageSource(BackgroundLayerSize, Colors.AliceBlue);
var backgroundLayer = new Layer(LayerStyle.Normal(), backgroundImage, BackgroundLayerSize);
var invariants = new LayerContext.Invariants(backgroundLayer, new MaybeTask <IImageProvider>(backgroundImage), new Size(0, 0));
var layerContext = new LayerContext(invariants, backgroundLayer, layer, 1);
layerContext.PreviousImage = layerContext.BackgroundImage;
return(layerContext);
}
private void CommandObjectProperties()
{
if (CommandCanObjectProperties())
{
foreach (ObjectInstance inst in _selectionManager.SelectedObjects)
{
LayerContext.ActivatePropertyProvider(inst);
break;
}
}
}
/// <summary>
/// Creates a new layer.
/// </summary>
/// <param name="parent">Optional. The parent of the layer (this can be another layer, too).
/// If this parameter is not specified or null is passed the game loop will be used as the parent.</param>
protected Layer(RegistrationTargetBase parent = null)
{
context = new LayerContext <TState, TRenderer>(this);
if (parent == null)
{
parent = GameEngine.QueryComponent <GameLoop>();
}
handle = parent.Register(context);
context.CurrentStateChanged += (sender, e) => Parallel.ForEach(Updateables, updateable => updateable.SetCurrentBufferIndex(context.CurrentState.BufferIndex));
}
private void ActivateObjectMenu(PointerEventInfo info)
{
CommandMenu menu = new CommandMenu("", new List <CommandMenuGroup>()
{
new CommandMenuGroup()
{
CommandKey.Cut, CommandKey.Copy, CommandKey.Paste, CommandKey.Delete,
},
new CommandMenuGroup()
{
CommandKey.ObjectProperties,
},
});
LayerContext.ActivateContextMenu(menu, new Point((int)info.X, (int)info.Y));
}
public Repository(LayerContext context)
{
db = context;
}
public DeliveryRepos(LayerContext context)
: base(context)
{
set = db.Deliveries;
}
public CourierRepos(LayerContext context)
: base(context)
{
set = db.Couriers;
}
internal static MaybeTask<IImageProvider> Apply(LayerContext context, MaybeTask<IImageProvider> image)
{
var layer = context.CurrentLayer;
var mask = new MaybeTask<IImageProvider>();
if (layer.Style.MaskResolver != null)
{
mask = layer.Style.MaskResolver(context);
}
const double opacityEpsilon = 0.01;
bool isOpaque = context.CurrentLayerIndex == 0 ||
((layer is AdjustmentLayer) &&
layer.Style.BlendFunction == BlendFunction.Normal &&
Math.Abs(layer.Style.Opacity - 1.0) <= opacityEpsilon);
if (isOpaque)
{
return new MaybeTask<IImageProvider>();
}
// This whole unfolded mess may look silly, but allows us to do the bare minimum.
// It defers resolving task-ness until later, so there are less objects allocated on average.
// Using async/await causes quite a few extra objects on the heap.
// We also try to avoid Task.FromResult which is at least one extra Task on the heap.
// Task.WhenAll is not efficient in .NET 4.0, and it's unknown how that translates to Silverlight for WP 8.0.
var blendParams = new BlendParams
{
PreviousImage = context.PreviousImage,
Image = image,
Mask = mask,
Style = layer.Style
};
if (blendParams.PreviousImage.IsSynchronous)
{
if (blendParams.Image.IsSynchronous)
{
if (blendParams.Mask.IsSynchronous || blendParams.Mask.IsEmpty)
{
return new MaybeTask<IImageProvider>(CreateBlendEffect(blendParams));
}
else
{
return new MaybeTask<IImageProvider>(
mask.Task.ContinueWith((maskTask, state) =>
{
var bp = (BlendParams)state;
bp.Mask = new MaybeTask<IImageProvider>(maskTask.Result);
return CreateBlendEffect(bp);
}, blendParams, ContinuationOptions));
}
}
else // image.IsAsynchronous
{
if (blendParams.Mask.IsSynchronous || blendParams.Mask.IsEmpty)
{
return new MaybeTask<IImageProvider>(
image.Task.ContinueWith((imageTask, state) =>
{
var bp = (BlendParams)state;
bp.Image = new MaybeTask<IImageProvider>(imageTask.Result);
return CreateBlendEffect(bp);
}, blendParams, ContinuationOptions));
}
else // mask.IsAsynchronous
{
return new MaybeTask<IImageProvider>(
image.Task.ContinueWith((imageTask, state) =>
{
var bp = (BlendParams)state;
bp.Image = new MaybeTask<IImageProvider>(imageTask.Result);
return bp.Mask.Task.ContinueWith((maskTask, state2) =>
{
var bp2 = (BlendParams)state2;
bp2.Mask = new MaybeTask<IImageProvider>(maskTask.Result);
return CreateBlendEffect(bp2);
}, bp, ContinuationOptions);
}, blendParams, ContinuationOptions).Unwrap());
}
}
}
else // previousImage.IsAsynchronous
{
if (blendParams.Image.IsSynchronous)
{
if (blendParams.Mask.IsSynchronous || blendParams.Mask.IsEmpty)
{
return new MaybeTask<IImageProvider>(
blendParams.PreviousImage.Task.ContinueWith((previousImageTask, state) =>
{
var bp = (BlendParams)state;
bp.PreviousImage = new MaybeTask<IImageProvider>(previousImageTask.Result);
return CreateBlendEffect(bp);
}, blendParams, ContinuationOptions));
}
else // mask.IsAsynchronous
{
return new MaybeTask<IImageProvider>(
blendParams.PreviousImage.Task.ContinueWith((previousImageTask, state2) =>
{
var blendParams2 = (BlendParams)state2;
blendParams2.PreviousImage = new MaybeTask<IImageProvider>(previousImageTask.Result);
return blendParams2.Mask.Task.ContinueWith((maskTask, state3) =>
{
var blendParams3 = (BlendParams)state3;
blendParams3.Mask = new MaybeTask<IImageProvider>(maskTask.Result);
return CreateBlendEffect(blendParams3);
}, blendParams2, ContinuationOptions);
}, blendParams, ContinuationOptions).Unwrap());
}
}
else // image.IsAsynchronous
{
if (mask.IsSynchronous || mask.IsEmpty)
{
return new MaybeTask<IImageProvider>(
blendParams.PreviousImage.Task.ContinueWith((previousImageTask, state) =>
{
var bp = (BlendParams)state;
bp.PreviousImage = new MaybeTask<IImageProvider>(previousImageTask.Result);
return bp.Image.Task.ContinueWith((imageTask, state2) =>
{
var bp2 = (BlendParams)state2;
bp2.Image = new MaybeTask<IImageProvider>(imageTask.Result);
return CreateBlendEffect(bp2);
}, bp, ContinuationOptions);
}, blendParams, ContinuationOptions).Unwrap());
}
else // mask.IsAsynchronous
{
return new MaybeTask<IImageProvider>(
blendParams.PreviousImage.Task.ContinueWith((previousImageTask, state) =>
{
var bp = (BlendParams)state;
bp.PreviousImage = new MaybeTask<IImageProvider>(previousImageTask.Result);
return bp.Image.Task.ContinueWith((imageTask, state2) =>
{
var bp2 = (BlendParams)state2;
bp2.Image = new MaybeTask<IImageProvider>(imageTask.Result);
return bp2.Mask.Task.ContinueWith((maskTask, state3) =>
{
var bp3 = (BlendParams)state3;
bp3.Mask = new MaybeTask<IImageProvider>(maskTask.Result);
return CreateBlendEffect(bp3);
}, bp2, ContinuationOptions);
}, bp, ContinuationOptions);
}, blendParams, ContinuationOptions).Unwrap().Unwrap());
}
}
}
throw new NotImplementedException();
}
public ProductAttributeRepos(LayerContext context)
: base(context)
{
db = context;
}
private Task <IImageProvider> CreateTestImageProviderAsync(LayerContext layerContext)
{
return(Task.Factory.StartNew <IImageProvider>(() => (IImageProvider) new ColorImageSource(layerContext.BackgroundLayer.ImageSize, Colors.Red), TaskCreationOptions.LongRunning));
}
public ProductRepos(LayerContext context)
: base(context)
{
set = db.Products;
}
public DeliveryProductRepos(LayerContext context)
: base(context)
{
set = db.DeliveriesProducts;
}
public EFUnitOfWork()
{
db = new LayerContext();
}
private IImageProvider CreateTestEffect(LayerContext layerContext)
{
return(new ReframingEffect(new Rect(new Point(0, 0), layerContext.BackgroundLayer.ImageSize), 0.0));
}
public AdminsRepos(LayerContext context)
: base(context)
{
set = db.Admins;
}
private IImageProvider CreateTestImageProvider(LayerContext layerContext)
{
return(new ColorImageSource(layerContext.BackgroundLayer.ImageSize, Colors.Red));
}
public ClientRepos(LayerContext context)
: base(context)
{
set = db.Clients;
}
internal static MaybeTask <IImageProvider> Apply(LayerContext context, MaybeTask <IImageProvider> image)
{
var layer = context.CurrentLayer;
var mask = new MaybeTask <IImageProvider>();
if (layer.Style.MaskResolver != null)
{
mask = layer.Style.MaskResolver(context);
}
const double opacityEpsilon = 0.01;
bool isOpaque = context.CurrentLayerIndex == 0 ||
((layer is AdjustmentLayer) &&
layer.Style.BlendFunction == BlendFunction.Normal &&
Math.Abs(layer.Style.Opacity - 1.0) <= opacityEpsilon);
if (isOpaque)
{
return(new MaybeTask <IImageProvider>());
}
// This whole unfolded mess may look silly, but allows us to do the bare minimum.
// It defers resolving task-ness until later, so there are less objects allocated on average.
// Using async/await causes quite a few extra objects on the heap.
// We also try to avoid Task.FromResult which is at least one extra Task on the heap.
// Task.WhenAll is not efficient in .NET 4.0, and it's unknown how that translates to Silverlight for WP 8.0.
var blendParams = new BlendParams
{
PreviousImage = context.PreviousImage,
Image = image,
Mask = mask,
Style = layer.Style
};
if (blendParams.PreviousImage.IsSynchronous)
{
if (blendParams.Image.IsSynchronous)
{
if (blendParams.Mask.IsSynchronous || blendParams.Mask.IsEmpty)
{
return(new MaybeTask <IImageProvider>(CreateBlendEffect(blendParams)));
}
else
{
return(new MaybeTask <IImageProvider>(
mask.Task.ContinueWith((maskTask, state) =>
{
var bp = (BlendParams)state;
bp.Mask = new MaybeTask <IImageProvider>(maskTask.Result);
return CreateBlendEffect(bp);
}, blendParams, ContinuationOptions)));
}
}
else // image.IsAsynchronous
{
if (blendParams.Mask.IsSynchronous || blendParams.Mask.IsEmpty)
{
return(new MaybeTask <IImageProvider>(
image.Task.ContinueWith((imageTask, state) =>
{
var bp = (BlendParams)state;
bp.Image = new MaybeTask <IImageProvider>(imageTask.Result);
return CreateBlendEffect(bp);
}, blendParams, ContinuationOptions)));
}
else // mask.IsAsynchronous
{
return(new MaybeTask <IImageProvider>(
image.Task.ContinueWith((imageTask, state) =>
{
var bp = (BlendParams)state;
bp.Image = new MaybeTask <IImageProvider>(imageTask.Result);
return bp.Mask.Task.ContinueWith((maskTask, state2) =>
{
var bp2 = (BlendParams)state2;
bp2.Mask = new MaybeTask <IImageProvider>(maskTask.Result);
return CreateBlendEffect(bp2);
}, bp, ContinuationOptions);
}, blendParams, ContinuationOptions).Unwrap()));
}
}
}
else // previousImage.IsAsynchronous
{
if (blendParams.Image.IsSynchronous)
{
if (blendParams.Mask.IsSynchronous || blendParams.Mask.IsEmpty)
{
return(new MaybeTask <IImageProvider>(
blendParams.PreviousImage.Task.ContinueWith((previousImageTask, state) =>
{
var bp = (BlendParams)state;
bp.PreviousImage = new MaybeTask <IImageProvider>(previousImageTask.Result);
return CreateBlendEffect(bp);
}, blendParams, ContinuationOptions)));
}
else // mask.IsAsynchronous
{
return(new MaybeTask <IImageProvider>(
blendParams.PreviousImage.Task.ContinueWith((previousImageTask, state2) =>
{
var blendParams2 = (BlendParams)state2;
blendParams2.PreviousImage = new MaybeTask <IImageProvider>(previousImageTask.Result);
return blendParams2.Mask.Task.ContinueWith((maskTask, state3) =>
{
var blendParams3 = (BlendParams)state3;
blendParams3.Mask = new MaybeTask <IImageProvider>(maskTask.Result);
return CreateBlendEffect(blendParams3);
}, blendParams2, ContinuationOptions);
}, blendParams, ContinuationOptions).Unwrap()));
}
}
else // image.IsAsynchronous
{
if (mask.IsSynchronous || mask.IsEmpty)
{
return(new MaybeTask <IImageProvider>(
blendParams.PreviousImage.Task.ContinueWith((previousImageTask, state) =>
{
var bp = (BlendParams)state;
bp.PreviousImage = new MaybeTask <IImageProvider>(previousImageTask.Result);
return bp.Image.Task.ContinueWith((imageTask, state2) =>
{
var bp2 = (BlendParams)state2;
bp2.Image = new MaybeTask <IImageProvider>(imageTask.Result);
return CreateBlendEffect(bp2);
}, bp, ContinuationOptions);
}, blendParams, ContinuationOptions).Unwrap()));
}
else // mask.IsAsynchronous
{
return(new MaybeTask <IImageProvider>(
blendParams.PreviousImage.Task.ContinueWith((previousImageTask, state) =>
{
var bp = (BlendParams)state;
bp.PreviousImage = new MaybeTask <IImageProvider>(previousImageTask.Result);
return bp.Image.Task.ContinueWith((imageTask, state2) =>
{
var bp2 = (BlendParams)state2;
bp2.Image = new MaybeTask <IImageProvider>(imageTask.Result);
return bp2.Mask.Task.ContinueWith((maskTask, state3) =>
{
var bp3 = (BlendParams)state3;
bp3.Mask = new MaybeTask <IImageProvider>(maskTask.Result);
return CreateBlendEffect(bp3);
}, bp2, ContinuationOptions);
}, bp, ContinuationOptions);
}, blendParams, ContinuationOptions).Unwrap().Unwrap()));
}
}
}
throw new NotImplementedException();
}
